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

Version Packages

.changeset/fifty-squids-wear.md

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

.changeset/red-lights-mix.md

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

.cursor/mcp.json

@@ -1,10 +1,19 @@
 {
 	"mcpServers": {
-        "taskmaster-ai": {
+		"task-master-ai": {
 			"command": "node",
-            "args": [
-                "./mcp-server/server.js"
-            ]
+			"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"
+			}
 		}
 	}
 }

.cursor/rules/ai_providers.mdc

@@ -0,0 +1,155 @@
+---
+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

@@ -0,0 +1,101 @@
+---
+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`.
+
+*   **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,7 +3,6 @@ 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.
@@ -14,114 +13,181 @@ 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 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.
+      - Invokes appropriate core logic functions from `scripts/modules/`.
+      - Handles user input/output for CLI.
+      - Implements CLI-specific validation.
 
-  - **[`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.
+  - **[`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.
     - **Responsibilities**:
-      - 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.
+      - 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`).
 
   - **[`dependency-manager.js`](mdc:scripts/modules/dependency-manager.js): Dependency Management**
-    - **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.
+    - **Purpose**: Manages task dependencies.
+    - **Responsibilities**: Add/remove/validate/fix dependencies.
 
   - **[`ui.js`](mdc:scripts/modules/ui.js): User Interface Components**
-    - **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.
+    - **Purpose**: Handles CLI output formatting (tables, colors, boxes, spinners).
+    - **Responsibilities**: Displaying tasks, reports, progress, suggestions.
 
-  - **[`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.
+  - **[`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/`).
 
-  - **[`utils.js`](mdc:scripts/modules/utils.js): Utility Functions and Configuration**
-    - **Purpose**: Provides reusable utility functions and global configuration settings used across the application.
+  - **[`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.
     - **Responsibilities** (See also: [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc)):
-      - 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.
-    - **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.
+      - 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`).
 
   - **[`mcp-server/`](mdc:mcp-server/): MCP Server Integration**
-    - **Purpose**: Provides an MCP (Model Context Protocol) interface for Task Master, allowing integration with external tools like Cursor. Uses FastMCP framework.
+    - **Purpose**: Provides MCP interface using FastMCP.
     - **Responsibilities** (See also: [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)):
-      - Registers Task Master functionalities as tools consumable via MCP.
-      - Handles MCP requests and translates them into calls to the Task Master core logic.
-      - Prefers direct function calls to core modules via [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js) for performance.
-      - Uses CLI execution via `executeTaskMasterCommand` as a fallback.
-      - **Implements Caching**: Utilizes a caching layer (`ContextManager` with `lru-cache`) invoked via `getCachedOrExecute` within direct function wrappers ([`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js)) to optimize performance for specific read operations (e.g., listing tasks).
-      - Standardizes response formatting for MCP clients using utilities in [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js).
-    - **Key Components**:
-      - `mcp-server/src/server.js`: Main server setup and initialization.
-      - `mcp-server/src/tools/`: Directory containing individual tool definitions, each registering a specific Task Master command for MCP.
+      - 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.
 
-- **Data Flow and Module Dependencies**:
+  - **[`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`.
 
-  - **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`, which then calls direct function wrappers in `task-master-core.js` or falls back to `executeTaskMasterCommand`. Responses are formatted by `mcp-server/src/tools/utils.js`. See [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) for details.
+- **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.
+
+## Silent Mode Implementation Pattern in MCP Direct Functions
+
+Direct functions (the `*Direct` functions in `mcp-server/src/core/direct-functions/`) need to carefully implement silent mode to prevent console logs from interfering with the structured JSON responses required by MCP. This involves both using `enableSilentMode`/`disableSilentMode` around core function calls AND passing the MCP logger via the standard wrapper pattern (see mcp.mdc). Here's the standard pattern for correct implementation:
+
+1. **Import Silent Mode Utilities**:
+   ```javascript
+   import { enableSilentMode, disableSilentMode, isSilentMode } from '../../../../scripts/modules/utils.js';
+   ```
+
+2. **Parameter Matching with Core Functions**:
+   - ✅ **DO**: Ensure direct function parameters match the core function parameters
+   - ✅ **DO**: Check the original core function signature before implementing
+   - ❌ **DON'T**: Add parameters to direct functions that don't exist in core functions
+   ```javascript
+   // Example: Core function signature
+   // async function expandTask(tasksPath, taskId, numSubtasks, useResearch, additionalContext, options)
+   
+   // Direct function implementation - extract only parameters that exist in core
+   export async function expandTaskDirect(args, log, context = {}) {
+     // Extract parameters that match the core function
+     const taskId = parseInt(args.id, 10);
+     const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
+     const useResearch = args.research === true;
+     const additionalContext = args.prompt || '';
+     
+     // Later pass these parameters in the correct order to the core function
+     const result = await expandTask(
+       tasksPath, 
+       taskId, 
+       numSubtasks, 
+       useResearch, 
+       additionalContext,
+       { mcpLog: log, session: context.session }
+     );
+   }
+   ```
+
+3. **Checking Silent Mode State**:
+   - ✅ **DO**: Always use `isSilentMode()` function to check current status
+   - ❌ **DON'T**: Directly access the global `silentMode` variable or `global.silentMode`
+   ```javascript
+   // CORRECT: Use the function to check current state
+   if (!isSilentMode()) {
+     // Only create a loading indicator if not in silent mode
+     loadingIndicator = startLoadingIndicator('Processing...');
+   }
+   
+   // INCORRECT: Don't access global variables directly
+   if (!silentMode) { // ❌ WRONG
+     loadingIndicator = startLoadingIndicator('Processing...');
+   }
+   ```
+
+4. **Wrapping Core Function Calls**:
+   - ✅ **DO**: Use a try/finally block pattern to ensure silent mode is always restored
+   - ✅ **DO**: Enable silent mode before calling core functions that produce console output
+   - ✅ **DO**: Disable silent mode in a finally block to ensure it runs even if errors occur
+   - ❌ **DON'T**: Enable silent mode without ensuring it gets disabled
+   ```javascript
+   export async function someDirectFunction(args, log) {
+     try {
+       // Argument preparation
+       const tasksPath = findTasksJsonPath(args, log);
+       const someArg = args.someArg;
+       
+       // Enable silent mode to prevent console logs
+       enableSilentMode();
+       
+       try {
+         // Call core function which might produce console output
+         const result = await someCoreFunction(tasksPath, someArg);
+         
+         // Return standardized result object
+         return { 
+           success: true, 
+           data: result, 
+           fromCache: false 
+         };
+       } finally {
+         // ALWAYS disable silent mode in finally block
+         disableSilentMode();
+       }
+     } catch (error) {
+       // Standard error handling
+       log.error(`Error in direct function: ${error.message}`);
+       return { 
+         success: false, 
+         error: { code: 'OPERATION_ERROR', message: error.message }, 
+         fromCache: false 
+       };
+     }
+   }
+   ```
+
+5. **Mixed Parameter and Global Silent Mode Handling**:
+   - For functions that need to handle both a passed `silentMode` parameter and check global state:
+   ```javascript
+   // Check both the function parameter and global state
+   const isSilent = options.silentMode || (typeof options.silentMode === 'undefined' && isSilentMode());
+   
+   if (!isSilent) {
+     console.log('Operation starting...');
+   }
+   ```
+
+By following these patterns consistently, direct functions will properly manage console output suppression while ensuring that silent mode is always properly reset, even when errors occur. This creates a more robust system that helps prevent unexpected silent mode states that could cause logging problems in subsequent operations.
 
 - **Testing Architecture**:
 
@@ -164,3 +230,56 @@ alwaysApply: false
   - **Clarity**: The modular structure provides a clear separation of concerns, making the codebase easier to navigate and understand for developers.
 
 This architectural overview should help AI models understand the structure and organization of the Task Master CLI codebase, enabling them to more effectively assist with code generation, modification, and understanding.
+
+## Implementing MCP Support for a Command
+
+Follow these steps to add MCP support for an existing Task Master command (see [`new_features.mdc`](mdc:.cursor/rules/new_features.mdc) for more detail):
+
+1.  **Ensure Core Logic Exists**: Verify the core functionality is implemented and exported from the relevant module in `scripts/modules/`.
+
+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` from `../utils/path-utils.js`**, and **silent mode utilities**.
+    - Implement `async function yourCommandDirect(args, log)` using **camelCase** with `Direct` suffix:
+        - **Path Resolution**: Obtain the tasks file path using `const tasksPath = findTasksJsonPath(args, log);`. This relies on `args.projectRoot` being provided.
+        - Parse other `args` and perform necessary validation.
+        - **Implement Silent Mode**: Wrap core function calls with `enableSilentMode()` and `disableSilentMode()`.
+        - Implement caching with `getCachedOrExecute` if applicable.
+        - Call core logic.
+        - Return `{ success: true/false, data/error, fromCache: boolean }`.
+    - Export the wrapper function.
+
+3.  **Update `task-master-core.js` with Import/Export**: Add imports/exports for the new `*Direct` function.
+
+4.  **Create MCP Tool (`mcp-server/src/tools/`)**:
+    - Create a new file (e.g., `your-command.js`) using **kebab-case**.
+    - Import `zod`, `handleApiResult`, **`getProjectRootFromSession`**, and your `yourCommandDirect` function.
+    - Implement `registerYourCommandTool(server)`.
+    - **Define parameters, making `projectRoot` optional**: `projectRoot: z.string().optional().describe(...)`.
+    - Consider if this operation should run in the background using `AsyncOperationManager`.
+    - Implement the standard `execute` method:
+      - Get `rootFolder` using `getProjectRootFromSession` (with fallback to `args.projectRoot`).
+      - Call `yourCommandDirect({ ...args, projectRoot: rootFolder }, log)` or use `asyncOperationManager.addOperation`.
+      - Pass the result to `handleApiResult`.
+
+5.  **Register Tool**: Import and call `registerYourCommandTool` in `mcp-server/src/tools/index.js`.
+
+6.  **Update `mcp.json`**: Add the new tool definition.
+
+## Project Initialization
+
+The `initialize_project` command provides a way to set up a new Task Master project:
+
+- **CLI Command**: `task-master init`
+- **MCP Tool**: `initialize_project`
+- **Functionality**:
+  - 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
+  - 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

.cursor/rules/changeset.mdc

@@ -0,0 +1,105 @@
+---
+description: Guidelines for using Changesets (npm run changeset) to manage versioning and changelogs.
+alwaysApply: true
+---
+
+# Changesets Workflow Guidelines
+
+Changesets is used to manage package versioning and generate accurate `CHANGELOG.md` files automatically. It's crucial to use it correctly after making meaningful changes that affect the package from an external perspective or significantly impact internal development workflow documented elsewhere.
+
+## When to Run Changeset
+
+- Run `npm run changeset` (or `npx changeset add`) **after** you have staged (`git add .`) a logical set of changes that should be communicated in the next release's `CHANGELOG.md`.
+- This typically includes:
+    - **New Features** (Backward-compatible additions)
+    - **Bug Fixes** (Fixes to existing functionality)
+    - **Breaking Changes** (Changes that are not backward-compatible)
+    - **Performance Improvements** (Enhancements to speed or resource usage)
+    - **Significant Refactoring** (Major code restructuring, even if external behavior is unchanged, as it might affect stability or maintainability) - *Such as reorganizing the MCP server's direct function implementations into separate files*
+    - **User-Facing Documentation Updates** (Changes to README, usage guides, public API docs)
+    - **Dependency Updates** (Especially if they fix known issues or introduce significant changes)
+    - **Build/Tooling Changes** (If they affect how consumers might build or interact with the package)
+- **Every Pull Request** containing one or more of the above change types **should include a changeset file**.
+
+## What NOT to Add a Changeset For
+
+Avoid creating changesets for changes that have **no impact or relevance to external consumers** of the `task-master` package or contributors following **public-facing documentation**. Examples include:
+
+- **Internal Documentation Updates:** Changes *only* to files within `.cursor/rules/` that solely guide internal development practices for this specific repository.
+- **Trivial Chores:** Very minor code cleanup, adding comments that don't clarify behavior, typo fixes in non-user-facing code or internal docs.
+- **Non-Impactful Test Updates:** Minor refactoring of tests, adding tests for existing functionality without fixing bugs.
+- **Local Configuration Changes:** Updates to personal editor settings, local `.env` files, etc.
+
+**Rule of Thumb:** If a user installing or using the `task-master` package wouldn't care about the change, or if a contributor following the main README wouldn't need to know about it for their workflow, you likely don't need a changeset.
+
+## How to Run and What It Asks
+
+1.  **Run the command**:
+    ```bash
+    npm run changeset
+    # or
+    npx changeset add
+    ```
+2.  **Select Packages**: It will prompt you to select the package(s) affected by your changes using arrow keys and spacebar. If this is not a monorepo, select the main package.
+3.  **Select Bump Type**: Choose the appropriate semantic version bump for **each** selected package:
+    *   **`Major`**: For **breaking changes**. Use sparingly.
+    *   **`Minor`**: For **new features**.
+    *   **`Patch`**: For **bug fixes**, performance improvements, **user-facing documentation changes**, significant refactoring, relevant dependency updates, or impactful build/tooling changes.
+4.  **Enter Summary**: Provide a concise summary of the changes **for the `CHANGELOG.md`**.
+    *   **Purpose**: This message is user-facing and explains *what* changed in the release.
+    *   **Format**: Use the imperative mood (e.g., "Add feature X", "Fix bug Y", "Update README setup instructions"). Keep it brief, typically a single line.
+    *   **Audience**: Think about users installing/updating the package or developers consuming its public API/CLI.
+    *   **Not a Git Commit Message**: This summary is *different* from your detailed Git commit message.
+
+## Changeset Summary vs. Git Commit Message
+
+- **Changeset Summary**:
+    - **Audience**: Users/Consumers of the package (reads `CHANGELOG.md`).
+    - **Purpose**: Briefly describe *what* changed in the released version that is relevant to them.
+    - **Format**: Concise, imperative mood, single line usually sufficient.
+    - **Example**: `Fix dependency resolution bug in 'next' command.`
+- **Git Commit Message**:
+    - **Audience**: Developers browsing the Git history of *this* repository.
+    - **Purpose**: Explain *why* the change was made, the context, and the implementation details (can include internal context).
+    - **Format**: Follows commit conventions (e.g., Conventional Commits), can be multi-line with a subject and body.
+    - **Example**:
+      ```
+      fix(deps): Correct dependency lookup in 'next' command
+
+      The logic previously failed to account for subtask dependencies when
+      determining the next available task. This commit refactors the
+      dependency check in `findNextTask` within `task-manager.js` to
+      correctly traverse both direct and subtask dependencies. Added
+      unit tests to cover this specific scenario.
+      ```
+- ✅ **DO**: Provide *both* a concise changeset summary (when appropriate) *and* a detailed Git commit message.
+- ❌ **DON'T**: Use your detailed Git commit message body as the changeset summary.
+- ❌ **DON'T**: Skip running `changeset` for user-relevant changes just because you wrote a good commit message.
+
+## The `.changeset` File
+
+- Running the command creates a unique markdown file in the `.changeset/` directory (e.g., `.changeset/random-name.md`).
+- This file contains the bump type information and the summary you provided.
+- **This file MUST be staged and committed** along with your relevant code changes.
+
+## Standard Workflow Sequence (When a Changeset is Needed)
+
+1.  Make your code or relevant documentation changes.
+2.  Stage your changes: `git add .`
+3.  Run changeset: `npm run changeset`
+    *   Select package(s).
+    *   Select bump type (`Patch`, `Minor`, `Major`).
+    *   Enter the **concise summary** for the changelog.
+4.  Stage the generated changeset file: `git add .changeset/*.md`
+5.  Commit all staged changes (code + changeset file) using your **detailed Git commit message**:
+    ```bash
+    git commit -m "feat(module): Add new feature X..."
+    ```
+
+## Release Process (Context)
+
+- The generated `.changeset/*.md` files are consumed later during the release process.
+- Commands like `changeset version` read these files, update `package.json` versions, update the `CHANGELOG.md`, and delete the individual changeset files.
+- Commands like `changeset publish` then publish the new versions to npm.
+
+Following this workflow ensures that versioning is consistent and changelogs are automatically and accurately generated based on the contributions made.

.cursor/rules/commands.mdc

@@ -6,6 +6,16 @@ alwaysApply: false
 
 # Command-Line Interface Implementation Guidelines
 
+**Note on Interaction Method:**
+
+While this document details the implementation of Task Master's **CLI commands**, the **preferred method for interacting with Task Master in integrated environments (like Cursor) is through the MCP server tools**. 
+
+- **Use MCP Tools First**: Always prefer using the MCP tools (e.g., `get_tasks`, `add_task`) when interacting programmatically or via an integrated tool. They offer better performance, structured data, and richer error handling. See [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc) for a comprehensive list of MCP tools and their corresponding CLI commands.
+- **CLI as Fallback/User Interface**: The `task-master` CLI commands described here are primarily intended for:
+    - Direct user interaction in the terminal.
+    - A fallback mechanism if the MCP server is unavailable or a specific functionality is not exposed via an MCP tool.
+- **Implementation Context**: This document (`commands.mdc`) focuses on the standards for *implementing* the CLI commands using Commander.js within the [`commands.js`](mdc:scripts/modules/commands.js) module.
+
 ## Command Structure Standards
 
 - **Basic Command Template**:
@@ -14,7 +24,7 @@ alwaysApply: false
   programInstance
     .command('command-name')
     .description('Clear, concise description of what the command does')
-    .option('-s, --short-option <value>', 'Option description', 'default value')
+    .option('-o, --option <value>', 'Option description', 'default value')
     .option('--long-option <value>', 'Option description')
     .action(async (options) => {
       // Command implementation
@@ -24,9 +34,130 @@ alwaysApply: false
 - **Command Handler Organization**:
   - ✅ DO: Keep action handlers concise and focused
   - ✅ DO: Extract core functionality to appropriate modules
-  - ✅ DO: Include validation for required parameters
+  - ✅ 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.
   - ❌ DON'T: Implement business logic in command handlers
 
+## Best Practices for Removal/Delete Commands
+
+When implementing commands that delete or remove data (like `remove-task` or `remove-subtask`), follow these specific guidelines:
+
+- **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**: Show what will be deleted in the confirmation message
+  - ❌ **DON'T**: Perform destructive operations without user confirmation unless explicitly overridden
+
+  ```javascript
+  // ✅ DO: Include confirmation for destructive operations
+  programInstance
+    .command('remove-task')
+    .description('Remove a task or subtask permanently')
+    .option('-i, --id <id>', 'ID of the task to remove')
+    .option('-y, --yes', 'Skip confirmation prompt', false)
+    .action(async (options) => {
+      // Validation code...
+      
+      if (!options.yes) {
+        const confirm = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'proceed',
+          message: `Are you sure you want to permanently delete task ${taskId}? This cannot be undone.`,
+          default: false
+        }]);
+        
+        if (!confirm.proceed) {
+          console.log(chalk.yellow('Operation cancelled.'));
+          return;
+        }
+      }
+      
+      // Proceed with removal...
+    });
+  ```
+
+- **File Path Handling**:
+  - ✅ **DO**: Use `path.join()` to construct file paths
+  - ✅ **DO**: Follow established naming conventions for tasks, like `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
+
+  ```javascript
+  // ✅ DO: Properly construct file paths
+  const taskFilePath = path.join(
+    path.dirname(tasksPath),
+    `task_${taskId.toString().padStart(3, '0')}.txt`
+  );
+  
+  // ✅ DO: Check existence before deletion
+  if (fs.existsSync(taskFilePath)) {
+    try {
+      fs.unlinkSync(taskFilePath);
+      console.log(chalk.green(`Task file deleted: ${taskFilePath}`));
+    } catch (error) {
+      console.warn(chalk.yellow(`Could not delete task file: ${error.message}`));
+    }
+  }
+  ```
+
+- **Clean Up References**:
+  - ✅ **DO**: Clean up references to the deleted item in other parts of the data
+  - ✅ **DO**: Handle both direct and indirect references
+  - ✅ **DO**: Explain what related data is being updated
+  - ❌ **DON'T**: Leave dangling references
+
+  ```javascript
+  // ✅ DO: Clean up references when deleting items
+  console.log(chalk.blue('Cleaning up task dependencies...'));
+  let referencesRemoved = 0;
+  
+  // Update dependencies in other tasks
+  data.tasks.forEach(task => {
+    if (task.dependencies && task.dependencies.includes(taskId)) {
+      task.dependencies = task.dependencies.filter(depId => depId !== taskId);
+      referencesRemoved++;
+    }
+  });
+  
+  if (referencesRemoved > 0) {
+    console.log(chalk.green(`Removed ${referencesRemoved} references to task ${taskId} from other tasks`));
+  }
+  ```
+
+- **Task File Regeneration**:
+  - ✅ **DO**: Regenerate task files after destructive operations
+  - ✅ **DO**: Pass all required parameters to generation functions
+  - ✅ **DO**: Provide an option to skip regeneration if needed
+  - ❌ **DON'T**: Assume default parameters will work
+
+  ```javascript
+  // ✅ DO: Properly regenerate files after deletion
+  if (!options.skipGenerate) {
+    console.log(chalk.blue('Regenerating task files...'));
+    try {
+      // Note both parameters are explicitly provided
+      await generateTaskFiles(tasksPath, path.dirname(tasksPath));
+      console.log(chalk.green('Task files regenerated successfully'));
+    } catch (error) {
+      console.warn(chalk.yellow(`Warning: Could not regenerate task files: ${error.message}`));
+    }
+  }
+  ```
+
+- **Alternative Suggestions**:
+  - ✅ **DO**: Suggest non-destructive alternatives when appropriate
+  - ✅ **DO**: Explain the difference between deletion and status changes
+  - ✅ **DO**: Include examples of alternative commands
+
+  ```javascript
+  // ✅ DO: Suggest alternatives for destructive operations
+  console.log(chalk.yellow('Note: If you just want to exclude this task from active work, consider:'));
+  console.log(chalk.cyan(`  task-master set-status --id='${taskId}' --status='cancelled'`));
+  console.log(chalk.cyan(`  task-master set-status --id='${taskId}' --status='deferred'`));
+  console.log('This preserves the task and its history for reference.');
+  ```
+
 ## Option Naming Conventions
 
 - **Command Names**:
@@ -35,10 +166,10 @@ alwaysApply: false
   - ✅ DO: Use descriptive, action-oriented names
 
 - **Option Names**:
-  - ✅ DO: Use kebab-case for long-form option names (`--output-format`)
-  - ✅ DO: Provide single-letter shortcuts when appropriate (`-f, --file`)
+  - ✅ DO: Use kebab-case for long-form option names, like `--output-format`
+  - ✅ DO: Provide single-letter shortcuts when appropriate, like `-f, --file`
   - ✅ DO: Use consistent option names across similar commands
-  - ❌ DON'T: Use different names for the same concept (`--file` in one command, `--path` in another)
+  - ❌ DON'T: Use different names for the same concept, such as `--file` in one command and `--path` in another
 
   ```javascript
   // ✅ DO: Use consistent option naming
@@ -50,7 +181,7 @@ alwaysApply: false
   .option('-p, --path <dir>', 'Output directory') // Should be --output
   ```
 
-  > **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']`.
+  > **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']`.
 
 - **Boolean Flag Conventions**:
   - ✅ DO: Use positive flags with `--skip-` prefix for disabling behavior
@@ -79,7 +210,7 @@ alwaysApply: false
 - **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
@@ -90,7 +221,7 @@ alwaysApply: false
   ```
 
 - **Parameter Type Conversion**:
-  - ✅ DO: Convert string inputs to appropriate types (numbers, booleans)
+  - ✅ DO: Convert string inputs to appropriate types, such as numbers or booleans
   - ✅ DO: Handle conversion errors gracefully
 
   ```javascript
@@ -123,7 +254,7 @@ alwaysApply: false
   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"'));
+    console.log(chalk.yellow("Usage example: task-master update-task --id='23' --prompt='Update with new information.\\nEnsure proper error handling.'"));
     process.exit(1);
   }
   
@@ -169,8 +300,8 @@ alwaysApply: false
     (dependencies.length > 0 ? chalk.white(`Dependencies: ${dependencies.join(', ')}`) + '\n' : '') +
     '\n' +
     chalk.white.bold('Next Steps:') + '\n' +
-    chalk.cyan(`1. Run ${chalk.yellow(`task-master show ${parentId}`)} to see the parent task with all subtasks`) + '\n' +
-    chalk.cyan(`2. Run ${chalk.yellow(`task-master set-status --id=${parentId}.${subtask.id} --status=in-progress`)} to start working on it`),
+    chalk.cyan(`1. Run ${chalk.yellow(`task-master show '${parentId}'`)} to see the parent task with all subtasks`) + '\n' +
+    chalk.cyan(`2. Run ${chalk.yellow(`task-master set-status --id='${parentId}.${subtask.id}' --status='in-progress'`)} to start working on it`),
     { padding: 1, borderColor: 'green', borderStyle: 'round', margin: { top: 1 } }
   ));
   ```
@@ -245,7 +376,7 @@ alwaysApply: false
       '  --option1 <value>    Description of option1 (required)\n' +
       '  --option2 <value>    Description of option2\n\n' +
       chalk.cyan('Examples:') + '\n' +
-      '  task-master command --option1=value --option2=value',
+      '  task-master command --option1=\'value1\' --option2=\'value2\'',
       { padding: 1, borderColor: 'blue', borderStyle: 'round' }
     ));
   }
@@ -261,9 +392,9 @@ alwaysApply: false
   process.on('uncaughtException', (err) => {
     // Handle Commander-specific errors
     if (err.code === 'commander.unknownOption') {
-      const option = err.message.match(/'([^']+)'/)?.[1];
+      const option = err.message.match(/'([^']+)'/)?.[1]; // Safely extract option name
       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);
     }
     
@@ -288,7 +419,7 @@ alwaysApply: false
     // Provide more helpful error messages for common issues
     if (error.message.includes('task') && error.message.includes('not found')) {
       console.log(chalk.yellow('\nTo fix this issue:'));
-      console.log('  1. Run task-master list to see all available task IDs');
+      console.log('  1. Run \'task-master list\' to see all available task IDs');
       console.log('  2. Use a valid task ID with the --id parameter');
     } else if (error.message.includes('API key')) {
       console.log(chalk.yellow('\nThis error is related to API keys. Check your environment variables.'));
@@ -333,9 +464,9 @@ alwaysApply: false
     .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 (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('-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('--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')
@@ -358,8 +489,8 @@ alwaysApply: false
     .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')
+    .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('--skip-generate', 'Skip regenerating task files')
     .action(async (options) => {
       // Implementation with detailed error handling
@@ -382,7 +513,8 @@ alwaysApply: false
   // ✅ DO: Implement version checking function
   async function checkForUpdate() {
     // Implementation details...
-    return { currentVersion, latestVersion, needsUpdate };
+    // Example return structure:
+    return { currentVersion, latestVersion, updateAvailable };
   }
   
   // ✅ DO: Implement semantic version comparison
@@ -422,7 +554,7 @@ alwaysApply: false
       
       // After command execution, check if an update is available
       const updateInfo = await updateCheckPromise;
-      if (updateInfo.needsUpdate) {
+      if (updateInfo.updateAvailable) {
         displayUpgradeNotification(updateInfo.currentVersion, updateInfo.latestVersion);
       }
     } catch (error) {
@@ -432,3 +564,45 @@ alwaysApply: false
   ```
 
 Refer to [`commands.js`](mdc:scripts/modules/commands.js) for implementation examples and [`new_features.mdc`](mdc:.cursor/rules/new_features.mdc) for integration guidelines. 
+// Helper function to show add-subtask command help
+function showAddSubtaskHelp() {
+  console.log(boxen(
+    chalk.white.bold('Add Subtask Command Help') + '\n\n' +
+    chalk.cyan('Usage:') + '\n' +
+    `  task-master add-subtask --parent=<id> [options]\n\n` +
+    chalk.cyan('Options:') + '\n' +
+    '  -p, --parent <id>         Parent task ID (required)\n' +
+    '  -i, --task-id <id>        Existing task ID to convert to subtask\n' +
+    '  -t, --title <title>       Title for the new subtask\n' +
+    '  -d, --description <text>  Description for the new subtask\n' +
+    '  --details <text>          Implementation details for the new subtask\n' +
+    '  --dependencies <ids>      Comma-separated list of dependency IDs\n' +
+    '  -s, --status <status>     Status for the new subtask (default: "pending")\n' +
+    '  -f, --file <file>         Path to the tasks file (default: "tasks/tasks.json")\n' +
+    '  --skip-generate           Skip regenerating task files\n\n' +
+    chalk.cyan('Examples:') + '\n' +
+    '  task-master add-subtask --parent=\'5\' --task-id=\'8\'\n' +
+    '  task-master add-subtask -p \'5\' -t \'Implement login UI\' -d \'Create the login form\'\n' +
+    '  task-master add-subtask -p \'5\' -t \'Handle API Errors\' --details $\'Handle 401 Unauthorized.\nHandle 500 Server Error.\'',
+    { padding: 1, borderColor: 'blue', borderStyle: 'round' }
+  ));
+}
+
+// Helper function to show remove-subtask command help
+function showRemoveSubtaskHelp() {
+  console.log(boxen(
+    chalk.white.bold('Remove Subtask Command Help') + '\n\n' +
+    chalk.cyan('Usage:') + '\n' +
+    `  task-master remove-subtask --id=<parentId.subtaskId> [options]\n\n` +
+    chalk.cyan('Options:') + '\n' +
+    '  -i, --id <id>       Subtask ID(s) to remove in format "parentId.subtaskId" (can be comma-separated, required)\n' +
+    '  -c, --convert       Convert the subtask to a standalone task instead of deleting it\n' +
+    '  -f, --file <file>   Path to the tasks file (default: "tasks/tasks.json")\n' +
+    '  --skip-generate     Skip regenerating task files\n\n' +
+    chalk.cyan('Examples:') + '\n' +
+    '  task-master remove-subtask --id=\'5.2\'\n' +
+    '  task-master remove-subtask --id=\'5.2,6.3,7.1\'\n' +
+    '  task-master remove-subtask --id=\'5.2\' --convert',
+    { padding: 1, borderColor: 'blue', borderStyle: 'round' }
+  ));
+} 

.cursor/rules/dev_workflow.mdc

@@ -1,223 +1,129 @@
 ---
-description: Guide for using meta-development script (scripts/dev.js) to manage task-driven development workflows
+description: Guide for using Task Master to manage task-driven development workflows
 globs: **/*
 alwaysApply: true
 ---
+# Task Master Development Workflow
 
-- **Global CLI Commands**
-  - Task Master now provides a global CLI through the `task-master` command (See [`commands.mdc`](mdc:.cursor/rules/commands.mdc) for details)
-  - All functionality from `scripts/dev.js` is available through this interface
-  - Install globally with `npm install -g claude-task-master` or use locally via `npx`
-  - Use `task-master <command>` instead of `node scripts/dev.js <command>`
-  - Examples:
-    - `task-master list`
-    - `task-master next`
-    - `task-master expand --id=3`
-  - All commands accept the same options as their script equivalents
-  - The CLI (`task-master`) is the **primary** way for users to interact with the application.
+This guide outlines the typical process for using Task Master to manage software development projects.
 
-- **Development Workflow Process**
-  - Start new projects by running `task-master init` or `node scripts/dev.js parse-prd --input=<prd-file.txt>` to generate initial tasks.json
-  - Begin coding sessions with `task-master list` to see current tasks, status, and IDs
-  - Analyze task complexity with `task-master analyze-complexity --research` before breaking down tasks
+## Primary Interaction: MCP Server vs. CLI
+
+Task Master offers two primary ways to interact:
+
+1.  **MCP Server (Recommended for Integrated Tools)**:
+    - For AI agents and integrated development environments (like Cursor), interacting via the **MCP server is the preferred method**.
+    - The MCP server exposes Task Master functionality through a set of tools (e.g., `get_tasks`, `add_subtask`).
+    - This method offers better performance, structured data exchange, and richer error handling compared to CLI parsing.
+    - Refer to [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) for details on the MCP architecture and available tools.
+    - A comprehensive list and description of MCP tools and their corresponding CLI commands can be found in [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc).
+    - **Restart the MCP server** if core logic in `scripts/modules` or MCP tool/direct function definitions change.
+
+2.  **`task-master` CLI (For Users & Fallback)**:
+    - The global `task-master` command provides a user-friendly interface for direct terminal interaction.
+    - It can also serve as a fallback if the MCP server is inaccessible or a specific function isn't exposed via MCP.
+    - Install globally with `npm install -g task-master-ai` or use locally via `npx task-master-ai ...`.
+    - The CLI commands often mirror the MCP tools (e.g., `task-master list` corresponds to `get_tasks`).
+    - Refer to [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc) for a detailed command reference.
+
+## 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
+-   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
+-   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 `task-master show <id>` to understand implementation requirements
-  - Break down complex tasks using `task-master expand --id=<id>` with appropriate flags
-  - Clear existing subtasks if needed using `task-master clear-subtasks --id=<id>` before regenerating
+-   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`.
+-   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
-  - Mark completed tasks with `task-master set-status --id=<id> --status=done`
-  - Update dependent tasks when implementation differs from original plan
-  - Generate task files with `task-master generate` after updating tasks.json
-  - Maintain valid dependency structure with `task-master fix-dependencies` when needed
+-   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 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
-  - **MCP Server**: For integrations (like Cursor), interact via the MCP server which prefers direct function calls. Restart the MCP server if core logic in `scripts/modules` changes. See [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc).
-  - Report progress regularly using the list command
+-   Report progress regularly using `get_tasks` / `task-master list`
 
-- **Task Complexity Analysis**
-  - Run `node scripts/dev.js analyze-complexity --research` for comprehensive analysis
-  - Review complexity report in scripts/task-complexity-report.json
-  - Or use `node scripts/dev.js complexity-report` for a formatted, readable version of the report
+## Task Complexity Analysis
+
+-   Run `analyze_project_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 command
+-   Note that reports are automatically used by the `expand_task` tool/command
 
-- **Task Breakdown Process**
-  - For tasks with complexity analysis, use `node scripts/dev.js expand --id=<id>`
-  - Otherwise use `node scripts/dev.js expand --id=<id> --subtasks=<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 to expand multiple pending tasks at once
-  - If subtasks need regeneration, clear them first with `clear-subtasks` command (See Command Reference below)
+## Task Breakdown Process
+
+-   Use `expand_task` / `task-master expand --id=<id>`. It automatically uses the complexity report if found, otherwise generates default number of subtasks.
+-   Use `--num=<number>` to specify an explicit number of subtasks, overriding defaults or complexity report recommendations.
+-   Add `--research` flag to leverage Perplexity AI for research-backed expansion.
+-   Add `--force` flag to clear existing subtasks before generating new ones (default is to append).
+-   Use `--prompt="<context>"` to provide additional context when needed.
+-   Review and adjust generated subtasks as necessary.
+-   Use `expand_all` tool or `task-master expand --all` to expand multiple pending tasks at once, respecting flags like `--force` and `--research`.
+-   If subtasks need complete replacement (regardless of the `--force` flag on `expand`), clear them first with `clear_subtasks` / `task-master clear-subtasks --id=<id>`.
+
+## Implementation Drift Handling
 
-- **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
-  - Call `node scripts/dev.js update --from=<futureTaskId> --prompt="<explanation>"` to update tasks.json
+-   Use `update` / `task-master update --from=<futureTaskId> --prompt='<explanation>\nUpdate context...' --research` to update multiple future tasks.
+-   Use `update_task` / `task-master update-task --id=<taskId> --prompt='<explanation>\nUpdate context...' --research` to update a single specific task.
+
+## Task Status Management
 
-- **Task Status Management**
 -   Use 'pending' for tasks ready to be worked on
 -   Use 'done' for completed and verified tasks
 -   Use 'deferred' for postponed tasks
 -   Add custom status values as needed for project-specific workflows
 
-- **Task File Format Reference**
-  ```
-  # Task ID: <id>
-  # Title: <title>
-  # Status: <status>
-  # Dependencies: <comma-separated list of dependency IDs>
-  # Priority: <priority>
-  # Description: <brief description>
-  # Details:
-  <detailed implementation notes>
+## Task Structure Fields
 
-  # Test Strategy:
-  <verification approach>
-  ```
-
-- **Command Reference: parse-prd**
-  - CLI Syntax: `task-master parse-prd --input=<prd-file.txt>`
-  - Description: Parses a PRD document and generates a `tasks.json` file with structured tasks
-  - Parameters: 
-    - `--input=<file>`: Path to the PRD text file (default: sample-prd.txt)
-  - Example: `task-master parse-prd --input=requirements.txt`
-  - Notes: Will overwrite existing tasks.json file. Use with caution.
-
-- **Command Reference: update**
-  - CLI Syntax: `task-master update --from=<id> --prompt="<prompt>"`
-  - Description: Updates tasks with ID >= specified ID based on the provided prompt
-  - Parameters:
-    - `--from=<id>`: Task ID from which to start updating (required)
-    - `--prompt="<text>"`: Explanation of changes or new context (required)
-  - Example: `task-master update --from=4 --prompt="Now we are using Express instead of Fastify."`
-  - Notes: Only updates tasks not marked as 'done'. Completed tasks remain unchanged.
-
-- **Command Reference: update-task**
-  - CLI Syntax: `task-master update-task --id=<id> --prompt="<prompt>"`
-  - Description: Updates a single task by ID with new information
-  - Parameters:
-    - `--id=<id>`: ID of the task to update (required)
-    - `--prompt="<text>"`: New information or context to update the task (required)
-    - `--research`: Use Perplexity AI for research-backed updates
-  - Example: `task-master update-task --id=5 --prompt="Use JWT for authentication instead of sessions."`
-  - Notes: Only updates tasks not marked as 'done'. Preserves completed subtasks.
-
-- **Command Reference: update-subtask**
-  - CLI Syntax: `task-master update-subtask --id=<id> --prompt="<prompt>"`
-  - Description: Appends additional information to a specific subtask without replacing existing content
-  - Parameters:
-    - `--id=<id>`: ID of the subtask to update in format "parentId.subtaskId" (required)
-    - `--prompt="<text>"`: Information to add to the subtask (required)
-    - `--research`: Use Perplexity AI for research-backed updates
-  - Example: `task-master update-subtask --id=5.2 --prompt="Add details about API rate limiting."`
-  - Notes: 
-    - Appends new information to subtask details with timestamp
-    - Does not replace existing content, only adds to it
-    - Uses XML-like tags to clearly mark added information
-    - Will not update subtasks marked as 'done' or 'completed'
-
-- **Command Reference: generate**
-  - CLI Syntax: `task-master generate`
-  - Description: Generates individual task files in tasks/ directory based on tasks.json
-  - Parameters: 
-    - `--file=<path>, -f`: Use alternative tasks.json file (default: 'tasks/tasks.json')
-    - `--output=<dir>, -o`: Output directory (default: 'tasks')
-  - Example: `task-master generate`
-  - Notes: Overwrites existing task files. Creates tasks/ directory if needed.
-
-- **Command Reference: set-status**
-  - CLI Syntax: `task-master set-status --id=<id> --status=<status>`
-  - Description: Updates the status of a specific task in tasks.json
-  - Parameters:
-    - `--id=<id>`: ID of the task to update (required)
-    - `--status=<status>`: New status value (required)
-  - Example: `task-master set-status --id=3 --status=done`
-  - Notes: Common values are 'done', 'pending', and 'deferred', but any string is accepted.
-
-- **Command Reference: list**
-  - CLI Syntax: `task-master list`
-  - Description: Lists all tasks in tasks.json with IDs, titles, and status
-  - Parameters: 
-    - `--status=<status>, -s`: Filter by status
-    - `--with-subtasks`: Show subtasks for each task
-    - `--file=<path>, -f`: Use alternative tasks.json file (default: 'tasks/tasks.json')
-  - Example: `task-master list`
-  - Notes: Provides quick overview of project progress. Use at start of sessions.
-
-- **Command Reference: expand**
-  - CLI Syntax: `task-master expand --id=<id> [--num=<number>] [--research] [--prompt="<context>"]`
-  - Description: Expands a task with subtasks for detailed implementation
-  - Parameters:
-    - `--id=<id>`: ID of task to expand (required unless using --all)
-    - `--all`: Expand all pending tasks, prioritized by complexity
-    - `--num=<number>`: Number of subtasks to generate (default: from complexity report)
-    - `--research`: Use Perplexity AI for research-backed generation
-    - `--prompt="<text>"`: Additional context for subtask generation
-    - `--force`: Regenerate subtasks even for tasks that already have them
-  - Example: `task-master expand --id=3 --num=5 --research --prompt="Focus on security aspects"`
-  - Notes: Uses complexity report recommendations if available.
-
-- **Command Reference: analyze-complexity**
-  - CLI Syntax: `task-master analyze-complexity [options]`
-  - Description: Analyzes task complexity and generates expansion recommendations
-  - Parameters:
-    - `--output=<file>, -o`: Output file path (default: scripts/task-complexity-report.json)
-    - `--model=<model>, -m`: Override LLM model to use
-    - `--threshold=<number>, -t`: Minimum score for expansion recommendation (default: 5)
-    - `--file=<path>, -f`: Use alternative tasks.json file
-    - `--research, -r`: Use Perplexity AI for research-backed analysis
-  - Example: `task-master analyze-complexity --research`
-  - Notes: Report includes complexity scores, recommended subtasks, and tailored prompts.
-
-- **Command Reference: clear-subtasks**
-  - CLI Syntax: `task-master clear-subtasks --id=<id>`
-  - Description: Removes subtasks from specified tasks to allow regeneration
-  - Parameters:
-    - `--id=<id>`: ID or comma-separated IDs of tasks to clear subtasks from
-    - `--all`: Clear subtasks from all tasks
-  - Examples:
-    - `task-master clear-subtasks --id=3`
-    - `task-master clear-subtasks --id=1,2,3`
-    - `task-master clear-subtasks --all`
-  - Notes: 
-    - Task files are automatically regenerated after clearing subtasks
-    - Can be combined with expand command to immediately generate new subtasks
-    - Works with both parent tasks and individual subtasks
-
-- **Task Structure Fields**
-  - **id**: Unique identifier for the task (Example: `1`)
+- **id**: Unique identifier for the task (Example: `1`, `1.1`)
 - **title**: Brief, descriptive title (Example: `"Initialize Repo"`)
 - **description**: Concise summary of what the task involves (Example: `"Create a new repository, set up initial structure."`)
 - **status**: Current state of the task (Example: `"pending"`, `"done"`, `"deferred"`)
-  - **dependencies**: IDs of prerequisite tasks (Example: `[1, 2]`)
+- **dependencies**: IDs of prerequisite tasks (Example: `[1, 2.1]`)
     - Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending)
     - This helps quickly identify which prerequisite tasks are blocking work
 - **priority**: Importance level (Example: `"high"`, `"medium"`, `"low"`)
 - **details**: In-depth implementation instructions (Example: `"Use GitHub client ID/secret, handle callback, set session token."`) 
 - **testStrategy**: Verification approach (Example: `"Deploy and call endpoint to confirm 'Hello World' response."`) 
 - **subtasks**: List of smaller, more specific tasks (Example: `[{"id": 1, "title": "Configure OAuth", ...}]`) 
+- Refer to task structure details (previously linked to `tasks.mdc`).
 
-- **Environment Variables Configuration**
-  - **ANTHROPIC_API_KEY** (Required): Your Anthropic API key for Claude (Example: `ANTHROPIC_API_KEY=sk-ant-api03-...`)
-  - **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`)
+## Configuration Management (Updated)
 
-- **Determining the Next Task**
-  - Run `task-master next` to show the next task to work on
-  - The next command identifies tasks with all dependencies satisfied
+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`, `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.
+
+## Determining the Next Task
+
+- Run `next_task` / `task-master next` to show the next task to work on.
+- The command identifies tasks with all dependencies satisfied
 - Tasks are prioritized by priority level, dependency count, and ID
 - The command shows comprehensive task information including:
     - Basic task details and description
@@ -229,8 +135,9 @@ alwaysApply: true
 - Ensures tasks are completed in the appropriate sequence
 - Provides ready-to-use commands for common task actions
 
-- **Viewing Specific Task Details**
-  - Run `task-master show <id>` or `task-master show --id=<id>` to view a specific task
+## Viewing Specific Task Details
+
+- Run `get_task` / `task-master show <id>` to view a specific task.
 - Use dot notation for subtasks: `task-master show 1.2` (shows subtask 2 of task 1)
 - Displays comprehensive information similar to the next command, but for a specific task
 - For parent tasks, shows all subtasks and their current status
@@ -238,108 +145,75 @@ alwaysApply: true
 - Provides contextual suggested actions appropriate for the specific task
 - Useful for examining task details before implementation or checking status
 
-- **Managing Task Dependencies**
-  - Use `task-master add-dependency --id=<id> --depends-on=<id>` to add a dependency
-  - Use `task-master remove-dependency --id=<id> --depends-on=<id>` to remove a dependency
+## Managing Task Dependencies
+
+- Use `add_dependency` / `task-master add-dependency --id=<id> --depends-on=<id>` to add a dependency.
+- Use `remove_dependency` / `task-master remove-dependency --id=<id> --depends-on=<id>` to remove a dependency.
 - The system prevents circular dependencies and duplicate dependency entries
 - Dependencies are checked for existence before being added or removed
 - Task files are automatically regenerated after dependency changes
 - Dependencies are visualized with status indicators in task listings and files
 
-- **Command Reference: add-dependency**
-  - CLI Syntax: `task-master add-dependency --id=<id> --depends-on=<id>`
-  - Description: Adds a dependency relationship between two tasks
-  - Parameters:
-    - `--id=<id>`: ID of task that will depend on another task (required)
-    - `--depends-on=<id>`: ID of task that will become a dependency (required)
-  - Example: `task-master add-dependency --id=22 --depends-on=21`
-  - Notes: Prevents circular dependencies and duplicates; updates task files automatically
+## Iterative Subtask Implementation
 
-- **Command Reference: remove-dependency**
-  - CLI Syntax: `task-master remove-dependency --id=<id> --depends-on=<id>`
-  - Description: Removes a dependency relationship between two tasks
-  - Parameters:
-    - `--id=<id>`: ID of task to remove dependency from (required)
-    - `--depends-on=<id>`: ID of task to remove as a dependency (required)
-  - Example: `task-master remove-dependency --id=22 --depends-on=21`
-  - Notes: Checks if dependency actually exists; updates task files automatically
+Once a task has been broken down into subtasks using `expand_task` or similar methods, follow this iterative process for implementation:
 
-- **Command Reference: validate-dependencies**
-  - CLI Syntax: `task-master validate-dependencies [options]`
-  - Description: Checks for and identifies invalid dependencies in tasks.json and task files
-  - Parameters:
-    - `--file=<path>, -f`: Use alternative tasks.json file (default: 'tasks/tasks.json')
-  - Example: `task-master validate-dependencies`
-  - Notes: 
-    - Reports all non-existent dependencies and self-dependencies without modifying files
-    - Provides detailed statistics on task dependency state
-    - Use before fix-dependencies to audit your task structure
+1.  **Understand the Goal (Preparation):**
+    *   Use `get_task` / `task-master show <subtaskId>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to thoroughly understand the specific goals and requirements of the subtask.
 
-- **Command Reference: fix-dependencies**
-  - CLI Syntax: `task-master fix-dependencies [options]`
-  - Description: Finds and fixes all invalid dependencies in tasks.json and task files
-  - Parameters:
-    - `--file=<path>, -f`: Use alternative tasks.json file (default: 'tasks/tasks.json')
-  - Example: `task-master fix-dependencies`
-  - Notes: 
-    - Removes references to non-existent tasks and subtasks
-    - Eliminates self-dependencies (tasks depending on themselves)
-    - Regenerates task files with corrected dependencies
-    - Provides detailed report of all fixes made
+2.  **Initial Exploration & Planning (Iteration 1):**
+    *   This is the first attempt at creating a concrete implementation plan.
+    *   Explore the codebase to identify the precise files, functions, and even specific lines of code that will need modification.
+    *   Determine the intended code changes (diffs) and their locations.
+    *   Gather *all* relevant details from this exploration phase.
 
-- **Command Reference: complexity-report**
-  - CLI Syntax: `task-master complexity-report [options]`
-  - Description: Displays the task complexity analysis report in a formatted, easy-to-read way
-  - Parameters:
-    - `--file=<path>, -f`: Path to the complexity report file (default: 'scripts/task-complexity-report.json')
-  - Example: `task-master complexity-report`
-  - Notes: 
-    - Shows tasks organized by complexity score with recommended actions
-    - Provides complexity distribution statistics
-    - Displays ready-to-use expansion commands for complex tasks
-    - If no report exists, offers to generate one interactively
+3.  **Log the Plan:**
+    *   Run `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<detailed plan>'`.
+    *   Provide the *complete and detailed* findings from the exploration phase in the prompt. Include file paths, line numbers, proposed diffs, reasoning, and any potential challenges identified. Do not omit details. The goal is to create a rich, timestamped log within the subtask's `details`.
 
-- **Command Reference: add-task**
-  - CLI Syntax: `task-master add-task [options]`
-  - Description: Add a new task to tasks.json using AI
-  - Parameters:
-    - `--file=<path>, -f`: Path to the tasks file (default: 'tasks/tasks.json')
-    - `--prompt=<text>, -p`: Description of the task to add (required)
-    - `--dependencies=<ids>, -d`: Comma-separated list of task IDs this task depends on
-    - `--priority=<priority>`: Task priority (high, medium, low) (default: 'medium')
-  - Example: `task-master add-task --prompt="Create user authentication using Auth0"`
-  - Notes: Uses AI to convert description into structured task with appropriate 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.
 
-- **Command Reference: init**
-  - CLI Syntax: `task-master init`
-  - Description: Initialize a new project with Task Master structure
-  - Parameters: None
-  - Example: `task-master init`
-  - Notes: 
-    - Creates initial project structure with required files
-    - Prompts for project settings if not provided
-    - Merges with existing files when appropriate
-    - Can be used to bootstrap a new Task Master project quickly
+5.  **Begin Implementation:**
+    *   Set the subtask status using `set_task_status` / `task-master set-status --id=<subtaskId> --status=in-progress`.
+    *   Start coding based on the logged plan.
 
-- **Code Analysis & Refactoring Techniques**
-  - **Top-Level Function Search**
-    - Use grep pattern matching to find all exported functions across the codebase
-    - Command: `grep -E "export (function|const) \w+|function \w+\(|const \w+ = \(|module\.exports" --include="*.js" -r ./`
-    - Benefits:
-      - Quickly identify all public API functions without reading implementation details
-      - Compare functions between files during refactoring (e.g., monolithic to modular structure)
-      - Verify all expected functions exist in refactored modules
-      - Identify duplicate functionality or naming conflicts
-    - Usage examples:
-      - When migrating from `scripts/dev.js` to modular structure: `grep -E "function \w+\(" scripts/dev.js`
-      - Check function exports in a directory: `grep -E "export (function|const)" scripts/modules/`
-      - Find potential naming conflicts: `grep -E "function (get|set|create|update)\w+\(" -r ./`
-    - Variations:
-      - Add `-n` flag to include line numbers
-      - Add `--include="*.ts"` to filter by file extension
-      - Use with `| sort` to alphabetize results
-    - Integration with refactoring workflow:
-      - Start by mapping all functions in the source file
-      - Create target module files based on function grouping
-      - Verify all functions were properly migrated
-      - Check for any unintentional duplications or omissions
+6.  **Refine and Log Progress (Iteration 2+):**
+    *   As implementation progresses, you will encounter challenges, discover nuances, or confirm successful approaches.
+    *   **Before appending new information**: Briefly review the *existing* details logged in the subtask (using `get_task` or recalling from context) to ensure the update adds fresh insights and avoids redundancy.
+    *   **Regularly** use `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<update details>\n- What worked...\n- What didn't work...'` to append new findings.
+    *   **Crucially, log:**
+        *   What worked ("fundamental truths" discovered).
+        *   What didn't work and why (to avoid repeating mistakes).
+        *   Specific code snippets or configurations that were successful.
+        *   Decisions made, especially if confirmed with user input.
+        *   Any deviations from the initial plan and the reasoning.
+    *   The objective is to continuously enrich the subtask's details, creating a log of the implementation journey that helps the AI (and human developers) learn, adapt, and avoid repeating errors.
+
+7.  **Review & Update Rules (Post-Implementation):**
+    *   Once the implementation for the subtask is functionally complete, review all code changes and the relevant chat history.
+    *   Identify any new or modified code patterns, conventions, or best practices established during the implementation.
+    *   Create new or update existing rules following internal guidelines (previously linked to `cursor_rules.mdc` and `self_improve.mdc`).
+
+8.  **Mark Task Complete:**
+    *   After verifying the implementation and updating any necessary rules, mark the subtask as completed: `set_task_status` / `task-master set-status --id=<subtaskId> --status=done`.
+
+9.  **Commit Changes (If using Git):**
+    *   Stage the relevant code changes and any updated/new rule files (`git add .`).
+    *   Craft a comprehensive Git commit message summarizing the work done for the subtask, including both code implementation and any rule adjustments.
+    *   Execute the commit command directly in the terminal (e.g., `git commit -m 'feat(module): Implement feature X for subtask <subtaskId>\n\n- Details about changes...\n- Updated rule Y for pattern Z'`).
+    *   Consider if a Changeset is needed according to internal versioning guidelines (previously linked to `changeset.mdc`). If so, run `npm run changeset`, stage the generated file, and amend the commit or create a new one.
+
+10. **Proceed to Next Subtask:**
+    *   Identify the next subtask (e.g., using `next_task` / `task-master next`).
+
+## Code Analysis & Refactoring Techniques
+
+- **Top-Level Function Search**:
+    - Useful for understanding module structure or planning refactors.
+    - Use grep/ripgrep to find exported functions/constants:
+      `rg "export (async function|function|const) \w+"` or similar patterns.
+    - Can help compare functions between files during migrations or identify potential naming conflicts.
+
+---
+*This workflow provides a general guideline. Adapt it based on your specific project needs and team practices.*

.cursor/rules/glossary.mdc

@@ -0,0 +1,26 @@
+---
+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.
+
+- **[`architecture.mdc`](mdc:.cursor/rules/architecture.mdc)**: Describes the high-level architecture of the Task Master CLI application.
+- **[`changeset.mdc`](mdc:.cursor/rules/changeset.mdc)**: Guidelines for using Changesets (npm run changeset) to manage versioning and changelogs.
+- **[`commands.mdc`](mdc:.cursor/rules/commands.mdc)**: Guidelines for implementing CLI commands using Commander.js.
+- **[`cursor_rules.mdc`](mdc:.cursor/rules/cursor_rules.mdc)**: Guidelines for creating and maintaining Cursor rules to ensure consistency and effectiveness.
+- **[`dependencies.mdc`](mdc:.cursor/rules/dependencies.mdc)**: Guidelines for managing task dependencies and relationships.
+- **[`dev_workflow.mdc`](mdc:.cursor/rules/dev_workflow.mdc)**: Guide for using Task Master to manage task-driven development workflows.
+- **[`glossary.mdc`](mdc:.cursor/rules/glossary.mdc)**: This file; provides a glossary of other Cursor rules.
+- **[`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)**: Guidelines for implementing and interacting with the Task Master MCP Server.
+- **[`new_features.mdc`](mdc:.cursor/rules/new_features.mdc)**: Guidelines for integrating new features into the Task Master CLI.
+- **[`self_improve.mdc`](mdc:.cursor/rules/self_improve.mdc)**: Guidelines for continuously improving Cursor rules based on emerging code patterns and best practices.
+- **[`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)**: Comprehensive reference for Taskmaster MCP tools and CLI commands.
+- **[`tasks.mdc`](mdc:.cursor/rules/tasks.mdc)**: Guidelines for implementing task management operations.
+- **[`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.
+

.cursor/rules/mcp.mdc

@@ -3,7 +3,6 @@ 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.
@@ -12,76 +11,514 @@ This document outlines the architecture and implementation patterns for the Task
 
 The MCP server acts as a bridge between external tools (like Cursor) and the core Task Master CLI logic. It leverages FastMCP for the server framework.
 
-- **Flow**: `External Tool (Cursor)` <-> `FastMCP Server` <-> `MCP Tools` (`mcp-server/src/tools/*.js`) <-> `Core Logic Wrappers` (`mcp-server/src/core/task-master-core.js`) <-> `Core Modules` (`scripts/modules/*.js`)
+- **Flow**: `External Tool (Cursor)` <-> `FastMCP Server` <-> `MCP Tools` (`mcp-server/src/tools/*.js`) <-> `Core Logic Wrappers` (`mcp-server/src/core/direct-functions/*.js`, exported via `task-master-core.js`) <-> `Core Modules` (`scripts/modules/*.js`)
 - **Goal**: Provide a performant and reliable way for external tools to interact with Task Master functionality without directly invoking the CLI for every operation.
 
+## Direct Function Implementation Best Practices
+
+When implementing a new direct function in `mcp-server/src/core/direct-functions/`, follow these critical guidelines:
+
+1. **Verify Function Dependencies**:
+   - ✅ **DO**: Check that all helper functions your direct function needs are properly exported from their source modules
+   - ✅ **DO**: Import these dependencies explicitly at the top of your file
+   - ❌ **DON'T**: Assume helper functions like `findTaskById` or `taskExists` are automatically available
+   - **Example**:
+     ```javascript
+     // At top of direct-function file
+     import { removeTask, findTaskById, taskExists } from '../../../../scripts/modules/task-manager.js';
+     ```
+
+2. **Parameter Verification and Completeness**:
+   - ✅ **DO**: Verify the signature of core functions you're calling and ensure all required parameters are provided
+   - ✅ **DO**: Pass explicit values for required parameters rather than relying on defaults
+   - ✅ **DO**: Double-check parameter order against function definition
+   - ❌ **DON'T**: Omit parameters assuming they have default values
+   - **Example**:
+     ```javascript
+     // Correct parameter handling in direct function
+     async function generateTaskFilesDirect(args, log) {
+       const tasksPath = findTasksJsonPath(args, log);
+       const outputDir = args.output || path.dirname(tasksPath);
+       
+       try {
+         // Pass all required parameters
+         const result = await generateTaskFiles(tasksPath, outputDir);
+         return { success: true, data: result, fromCache: false };
+       } catch (error) {
+         // Error handling...
+       }
+     }
+     ```
+
+3. **Consistent File Path Handling**:
+   - ✅ **DO**: Use `path.join()` instead of string concatenation for file paths
+   - ✅ **DO**: Follow established file naming conventions (`task_001.txt` not `1.md`)
+   - ✅ **DO**: Use `path.dirname()` and other path utilities for manipulating paths
+   - ✅ **DO**: When paths relate to task files, follow the standard format: `task_${id.toString().padStart(3, '0')}.txt`
+   - ❌ **DON'T**: Create custom file path handling logic that diverges from established patterns
+   - **Example**:
+     ```javascript
+     // Correct file path handling
+     const taskFilePath = path.join(
+       path.dirname(tasksPath),
+       `task_${taskId.toString().padStart(3, '0')}.txt`
+     );
+     ```
+
+4. **Comprehensive Error Handling**:
+   - ✅ **DO**: Wrap core function calls *and AI calls* in try/catch blocks
+   - ✅ **DO**: Log errors with appropriate severity and context
+   - ✅ **DO**: Return standardized error objects with code and message (`{ success: false, error: { code: '...', message: '...' } }`)
+   - ✅ **DO**: Handle file system errors, AI client errors, AI processing errors, and core function errors distinctly with appropriate codes.
+   - **Example**:
+     ```javascript
+     try {
+       // Core function call or AI logic
+     } catch (error) {
+       log.error(`Failed to execute direct function logic: ${error.message}`);
+       return {
+         success: false,
+         error: {
+           code: error.code || 'DIRECT_FUNCTION_ERROR', // Use specific codes like AI_CLIENT_ERROR, etc.
+           message: error.message,
+           details: error.stack // Optional: Include stack in debug mode
+         },
+         fromCache: false // Ensure this is included if applicable
+       };
+     }
+     ```
+
+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.
+     ```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)
+     };
+
+     // ... later when calling the core function ...
+     await coreFunction(
+       // ... other arguments ...
+       { 
+         mcpLog: logWrapper, // Pass the wrapper object
+         session // Also pass session if needed by core logic or AI service
+       },
+       '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`.
+
+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)**:
+      ```javascript
+      export async function coreWrapperDirect(args, log, context = {}) {
+        const { session } = context;
+        const tasksPath = findTasksJsonPath(args, log);
+        const logWrapper = { /* ... */ };
+
+        enableSilentMode(); // Ensure silence for direct console output
+        try {
+          const result = await coreFunction(
+             tasksPath,
+             args.param1,
+             { mcpLog: logWrapper, session }, // Pass context
+             'json' // Request JSON format if supported
+          );
+          return { success: true, data: result };
+        } catch (error) {
+           log.error(`Error: ${error.message}`);
+           return { success: false, error: { /* ... */ } };
+        } finally {
+           disableSilentMode(); // Critical: Always disable in finally
+        }
+      }
+      ```
+
+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.
+
+## Tool Definition and Execution
+
+### Tool Structure
+
+MCP tools must follow a specific structure to properly interact with the FastMCP framework:
+
+```javascript
+server.addTool({
+  name: "tool_name",  // Use snake_case for tool names
+  description: "Description of what the tool does",
+  parameters: z.object({
+    // Define parameters using Zod
+    param1: z.string().describe("Parameter description"),
+    param2: z.number().optional().describe("Optional parameter description"),
+    // IMPORTANT: For file operations, always include these optional parameters
+    file: z.string().optional().describe("Path to the tasks file"),
+    projectRoot: z.string().optional().describe("Root directory of the project (typically derived from session)")
+  }),
+
+  // The execute function is the core of the tool implementation
+  execute: async (args, context) => {
+    // Implementation goes here
+    // Return response in the appropriate format
+  }
+});
+```
+
+### Execute Function Signature
+
+The `execute` function receives validated arguments and the FastMCP context:
+
+```javascript
+// Destructured signature (recommended)
+execute: async (args, { log, session }) => {
+  // Tool implementation
+}
+```
+
+- **args**: Validated parameters.
+- **context**: Contains `{ log, session }` from FastMCP. (Removed `reportProgress`).
+
+### Standard Tool Execution Pattern with Path Normalization (Updated)
+
+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).
+
+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.  **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:**
+
+```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
+
+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;
+
+            try {
+                log.info(`Executing your_tool with normalized root: ${projectRoot}`);
+
+                // Resolve paths using the normalized projectRoot
+                let tasksPath = findTasksJsonPath({ projectRoot, file: args.file }, log);
+
+                // 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 }
+                );
+
+                return handleApiResult(result, log);
+            } catch (error) {
+                log.error(`Error in your_tool: ${error.message}`);
+                return createErrorResponse(error.message);
+            }
+        }) // End HOF wrap
+    });
+}
+```
+
+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.
+
+### Project Initialization Tool
+
+The `initialize_project` tool allows integrated clients like Cursor to set up a new Task Master project:
+
+```javascript
+// In initialize-project.js
+import { z } from "zod";
+import { initializeProjectDirect } from "../core/task-master-core.js";
+import { handleApiResult, createErrorResponse } from "./utils.js";
+
+export function registerInitializeProjectTool(server) {
+  server.addTool({
+    name: "initialize_project",
+    description: "Initialize a new Task Master project",
+    parameters: z.object({
+      projectName: z.string().optional().describe("The name for the new project"),
+      projectDescription: z.string().optional().describe("A brief description"),
+      projectVersion: z.string().optional().describe("Initial version (e.g., '0.1.0')"),
+      authorName: z.string().optional().describe("The author's name"),
+      skipInstall: z.boolean().optional().describe("Skip installing dependencies"),
+      addAliases: z.boolean().optional().describe("Add shell aliases"),
+      yes: z.boolean().optional().describe("Skip prompts and use defaults")
+    }),
+    execute: async (args, { log, reportProgress }) => {
+      try {
+        // Since we're initializing, we don't need project root
+        const result = await initializeProjectDirect(args, log);
+        return handleApiResult(result, log, 'Error initializing project');
+      } catch (error) {
+        log.error(`Error in initialize_project: ${error.message}`);
+        return createErrorResponse(`Failed to initialize project: ${error.message}`);
+      }
+    }
+  });
+}
+```
+
+### Logging Convention
+
+The `log` object (destructured from `context`) provides standardized logging methods. Use it within both the `execute` method and the `*Direct` functions. **If progress indication is needed within a direct function, use `log.info()` instead of `reportProgress`**.
+
+```javascript
+// Proper logging usage
+log.info(`Starting ${toolName} with parameters: ${JSON.stringify(sanitizedArgs)}`);
+log.debug("Detailed operation info", { data });
+log.warn("Potential issue detected");
+log.error(`Error occurred: ${error.message}`, { stack: error.stack });
+log.info('Progress: 50% - AI call initiated...'); // Example progress logging
+```
+
+## 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.
+- **Capabilities**: Can be used to check client capabilities (`session.clientCapabilities`).
+
+## Direct Function Wrappers (`*Direct`)
+
+These functions, located in `mcp-server/src/core/direct-functions/`, form the core logic execution layer for MCP tools.
+
+- **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.
+
 ## Key Principles
 
-- **Prefer Direct Function Calls**: For optimal performance and error handling, MCP tools should utilize direct function wrappers defined in [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js). These wrappers call the underlying logic from the core modules (e.g., [`task-manager.js`](mdc:scripts/modules/task-manager.js)).
-- **Use `executeMCPToolAction`**: This utility function in [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) is the standard wrapper for executing the main logic within an MCP tool's `execute` function. It handles common boilerplate like logging, argument processing, calling the core action (`*Direct` function), and formatting the response.
-- **CLI Execution as Fallback**: The `executeTaskMasterCommand` utility in [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) allows executing commands via the CLI (`task-master ...`). This should **only** be used as a fallback if a direct function wrapper is not yet implemented or if a specific command intrinsically requires CLI execution.
-- **Centralized Utilities** (See also: [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc)):
-    - Use `findTasksJsonPath` (in [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js)) within direct function wrappers to locate the `tasks.json` file consistently.
-    - **Leverage MCP Utilities**: The file [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) contains essential helpers for MCP tool implementation:
-        - `getProjectRoot`: Normalizes project paths (used internally by other utils).
-        - `handleApiResult`: Standardizes handling results from direct function calls (success/error).
-        - `createContentResponse`/`createErrorResponse`: Formats successful/error MCP responses.
-        - `processMCPResponseData`: Filters/cleans data for MCP responses (e.g., removing `details`, `testStrategy`). This is the default processor used by `executeMCPToolAction`.
-        - `executeMCPToolAction`: The primary wrapper function for tool execution logic.
-        - `executeTaskMasterCommand`: Fallback for executing CLI commands.
-- **Caching**: To improve performance for frequently called read operations (like `listTasks`), a caching layer using `lru-cache` is implemented.
-    - Caching logic should be added *inside* the direct function wrappers in [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js) using the `getCachedOrExecute` utility from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js).
-    - Generate unique cache keys based on function arguments that define a distinct call.
-    - Responses will include a `fromCache` flag.
-    - Cache statistics can be monitored using the `cacheStats` MCP tool (implemented via `getCacheStatsDirect`).
+- **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.
+- **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.
+- **Output Formatting**: Ensure core functions called by `*Direct` functions can suppress CLI output, ideally via an `outputFormat` parameter.
+- **Project Initialization**: Use the initialize_project tool for setting up new projects in integrated environments.
+- **Centralized Utilities**: Use helpers from `mcp-server/src/tools/utils.js`, `mcp-server/src/core/utils/path-utils.js`, and `mcp-server/src/core/utils/ai-client-utils.js`. See [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc).
+- **Caching in Direct Functions**: Caching logic resides *within* the `*Direct` functions using `getCachedOrExecute`.
+
+## Resources and Resource Templates
+
+Resources provide LLMs with static or dynamic data without executing tools.
+
+- **Implementation**: Use `@mcp.resource()` decorator pattern or `server.addResource`/`server.addResourceTemplate` in `mcp-server/src/core/resources/`.
+- **Registration**: Register resources during server initialization in [`mcp-server/src/index.js`](mdc:mcp-server/src/index.js).
+- **Best Practices**: Organize resources, validate parameters, use consistent URIs, handle errors. See [`fastmcp-core.txt`](docs/fastmcp-core.txt) for underlying SDK details.
+
+*(Self-correction: Removed detailed Resource implementation examples as they were less relevant to the current user focus on tool execution flow and project roots. Kept the overview.)*
 
 ## Implementing MCP Support for a Command
 
 Follow these steps to add MCP support for an existing Task Master command (see [`new_features.mdc`](mdc:.cursor/rules/new_features.mdc) for more detail):
 
-1.  **Ensure Core Logic Exists**: Verify the core functionality is implemented and exported from the relevant module in `scripts/modules/`.
- 2.  **Create Direct Wrapper**: In [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js):
-        - Import the core function.
-        - Import `getCachedOrExecute` from `../tools/utils.js`.
-        - Create an `async function yourCommandDirect(args, log)` wrapper.
-        - Inside the wrapper:
-            - Determine arguments needed for both the core logic and the cache key (e.g., `tasksPath`, filters). Use `findTasksJsonPath(args, log)` if needed.
-            - **Generate a unique `cacheKey`** based on the arguments that define a distinct operation (e.g., `\`yourCommand:${tasksPath}:${filter}\``).
-            - **Define the `coreActionFn`**: An `async` function that contains the actual call to the imported core logic function, handling its specific errors and returning `{ success: true/false, data/error }`.
-            - **Call `getCachedOrExecute`**:
-              ```javascript
-              const result = await getCachedOrExecute({
-                cacheKey,
-                actionFn: coreActionFn, // The function wrapping the core logic call
-                log
-              });
-              return result; // Returns { success, data/error, fromCache }
-              ```
-        - Export the wrapper function and add it to the `directFunctions` map.
-3.  **Create MCP Tool**: In `mcp-server/src/tools/`:
-    - Create a new file (e.g., `yourCommand.js`).
-    - Import `z` for parameter schema definition.
-    - Import `executeMCPToolAction` from [`./utils.js`](mdc:mcp-server/src/tools/utils.js).
-    - Import the `yourCommandDirect` wrapper function from `../core/task-master-core.js`.
-    - Implement `registerYourCommandTool(server)`:
-        - Call `server.addTool`.
-        - Define `name`, `description`, and `parameters` using `zod`. Include `projectRoot` and `file` as optional parameters if relevant.
-        - Define the `async execute(args, log)` function.
-        - Inside `execute`, call `executeMCPToolAction`:
-          ```javascript
-          return executeMCPToolAction({
-            actionFn: yourCommandDirect, // The direct function wrapper
-            args,                     // Arguments from the tool call
-            log,                      // MCP logger instance
-            actionName: 'Your Command Description', // For logging
-            // processResult: customProcessor // Optional: if default filtering isn't enough
-          });
-          ```
-4.  **Register Tool**: Import and call `registerYourCommandTool` in [`mcp-server/src/tools/index.js`](mdc:mcp-server/src/tools/index.js).
-5.  **Update `mcp.json`**: Add the new tool definition to the `tools` array in `.cursor/mcp.json`.
+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/`**:
+    - 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).**
+        - **Path Resolution**: Obtain `tasksPath` using `findTasksJsonPath(args, log)`.
+        - Parse other `args` and perform necessary validation.
+        - **Handle AI (if applicable)**: Initialize clients using `get*ClientForMCP(session, log)`, build prompts, call AI, parse response. Handle AI-specific errors.
+        - **Implement Caching (if applicable)**: Use `getCachedOrExecute`.
+        - **Call Core Logic**:
+            - Wrap with `enableSilentMode/disableSilentMode` if necessary.
+            - Pass `outputFormat: 'json'` (or similar) if applicable.
+            - Handle errors from the core function.
+        - Format the return as `{ success: true/false, data/error, fromCache?: boolean }`.
+        - ❌ **DON'T**: Call `reportProgress`.
+    - Export the wrapper function.
+
+3.  **Update `task-master-core.js` with Import/Export**: Import and re-export your `*Direct` function and add it to the `directFunctions` map.
+
+4.  **Create MCP Tool (`mcp-server/src/tools/`)**:
+    - Create a new file (e.g., `your-command.js`) using **kebab-case**.
+    - Import `zod`, `handleApiResult`, `createErrorResponse`, `getProjectRootFromSession`, and your `yourCommandDirect` function. Import `AsyncOperationManager` if needed.
+    - Implement `registerYourCommandTool(server)`.
+    - Define the tool `name` using **snake_case** (e.g., `your_command`).
+    - Define the `parameters` using `zod`. Include `projectRoot: z.string().optional()`.
+    - Implement the `async execute(args, { log, session })` method (omitting `reportProgress` from destructuring).
+        - Get `rootFolder` using `getProjectRootFromSession(session, log)`.
+        - **Determine Execution Strategy**:
+            - **If using `AsyncOperationManager`**: Create the operation, call the `*Direct` function from within the async task callback (passing `log` and `{ session }`), report progress *from the callback*, and return the initial `ACCEPTED` response.
+            - **If calling `*Direct` function synchronously** (like `add-task`): Call `await yourCommandDirect({ ...args, projectRoot }, log, { session });`. Handle the result with `handleApiResult`.
+        - ❌ **DON'T**: Pass `reportProgress` down to the direct function in either case.
+
+5.  **Register Tool**: Import and call `registerYourCommandTool` in `mcp-server/src/tools/index.js`.
+
+6.  **Update `mcp.json`**: Add the new tool definition to the `tools` array in `.cursor/mcp.json`.
 
 ## Handling Responses
 
-- MCP tools should return data formatted by `createContentResponse` (which stringifies objects) or `createErrorResponse`.
-- The `processMCPResponseData` utility automatically removes potentially large fields like `details` and `testStrategy` from task objects before they are returned. This is the default behavior when using `executeMCPToolAction`. If specific fields need to be preserved or different fields removed, a custom `processResult` function can be passed to `executeMCPToolAction`.
-- The `handleApiResult` utility (used by `executeMCPToolAction`) now expects the result object from the direct function wrapper to include a `fromCache` boolean flag. This flag is included in the final JSON response sent to the MCP client, nested alongside the actual data (e.g., `{ "fromCache": true, "data": { ... } }`).
+- MCP tools should return the object generated by `handleApiResult`.
+- `handleApiResult` uses `createContentResponse` or `createErrorResponse` internally.
+- `handleApiResult` also uses `processMCPResponseData` by default to filter potentially large fields (`details`, `testStrategy`) from task data. Provide a custom processor function to `handleApiResult` if different filtering is needed.
+- The final JSON response sent to the MCP client will include the `fromCache` boolean flag (obtained from the `*Direct` function's result) alongside the actual data (e.g., `{ "fromCache": true, "data": { ... } }` or `{ "fromCache": false, "data": { ... } }`).
+
+## Parameter Type Handling
+
+- **Prefer Direct Function Calls**: For optimal performance and error handling, MCP tools should utilize direct function wrappers defined in [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js). These wrappers call the underlying logic from the core modules (e.g., [`task-manager.js`](mdc:scripts/modules/task-manager.js)).
+- **Standard Tool Execution Pattern**:
+    - The `execute` method within each MCP tool (in `mcp-server/src/tools/*.js`) should:
+        1.  Call the corresponding `*Direct` function wrapper (e.g., `listTasksDirect`) from [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js), passing necessary arguments and the logger.
+        2.  Receive the result object (typically `{ success, data/error, fromCache }`).
+        3.  Pass this result object to the `handleApiResult` utility (from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js)) for standardized response formatting and error handling.
+        4.  Return the formatted response object provided by `handleApiResult`.
+- **CLI Execution as Fallback**: The `executeTaskMasterCommand` utility in [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) allows executing commands via the CLI (`task-master ...`). This should **only** be used as a fallback if a direct function wrapper is not yet implemented or if a specific command intrinsically requires CLI execution.
+- **Centralized Utilities** (See also: [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc)):
+    - Use `findTasksJsonPath` (in [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js)) *within direct function wrappers* to locate the `tasks.json` file consistently.
+    - **Leverage MCP Utilities**: The file [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) contains essential helpers for MCP tool implementation:
+        - `getProjectRoot`: Normalizes project paths.
+        - `handleApiResult`: Takes the raw result from a `*Direct` function and formats it into a standard MCP success or error response, automatically handling data processing via `processMCPResponseData`. This is called by the tool's `execute` method.
+        - `createContentResponse`/`createErrorResponse`: Used by `handleApiResult` to format successful/error MCP responses.
+        - `processMCPResponseData`: Filters/cleans data (e.g., removing `details`, `testStrategy`) before it's sent in the MCP response. Called by `handleApiResult`.
+        - `getCachedOrExecute`: **Used inside `*Direct` functions** in `task-master-core.js` to implement caching logic.
+        - `executeTaskMasterCommand`: Fallback for executing CLI commands.
+- **Caching**: To improve performance for frequently called read operations (like `listTasks`, `showTask`, `nextTask`), a caching layer using `lru-cache` is implemented.
+    - **Caching logic resides *within* the direct function wrappers** in [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js) using the `getCachedOrExecute` utility from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js).
+    - Generate unique cache keys based on function arguments that define a distinct call (e.g., file path, filters).
+    - The `getCachedOrExecute` utility handles checking the cache, executing the core logic function on a cache miss, storing the result, and returning the data along with a `fromCache` flag.
+    - Cache statistics can be monitored using the `cacheStats` MCP tool (implemented via `getCacheStatsDirect`).
+    - **Caching should generally be applied to read-only operations** that don't modify the `tasks.json` state. Commands like `set-status`, `add-task`, `update-task`, `parse-prd`, `add-dependency` should *not* be cached as they change the underlying data.
+
+**MCP Tool Implementation Checklist**:
+
+1. **Core Logic Verification**:
+   - [ ] Confirm the core function is properly exported from its module (e.g., `task-manager.js`)
+   - [ ] Identify all required parameters and their types
+
+2. **Direct Function Wrapper**:
+   - [ ] Create the `*Direct` function in the appropriate file in `mcp-server/src/core/direct-functions/`
+   - [ ] Import silent mode utilities and implement them around core function calls
+   - [ ] Handle all parameter validations and type conversions
+   - [ ] Implement path resolving for relative paths
+   - [ ] Add appropriate error handling with standardized error codes
+   - [ ] Add to imports/exports in `task-master-core.js`
+
+3. **MCP Tool Implementation**:
+   - [ ] Create new file in `mcp-server/src/tools/` with kebab-case naming
+   - [ ] Define zod schema for all parameters
+   - [ ] Implement the `execute` method following the standard pattern
+   - [ ] Consider using AsyncOperationManager for long-running operations
+   - [ ] Register tool in `mcp-server/src/tools/index.js`
+
+4. **Testing**:
+   - [ ] Write unit tests for the direct function wrapper
+   - [ ] Write integration tests for the MCP tool
+
+## Standard Error Codes
+
+- **Standard Error Codes**: Use consistent error codes across direct function wrappers
+  - `INPUT_VALIDATION_ERROR`: For missing or invalid required parameters
+  - `FILE_NOT_FOUND_ERROR`: For file system path issues
+  - `CORE_FUNCTION_ERROR`: For errors thrown by the core function
+  - `UNEXPECTED_ERROR`: For all other unexpected errors
+
+- **Error Object Structure**:
+  ```javascript
+  {
+    success: false,
+    error: {
+      code: 'ERROR_CODE',
+      message: 'Human-readable error message'
+    },
+    fromCache: false
+  }
+  ```
+
+- **MCP Tool Logging Pattern**:
+  - ✅ DO: Log the start of execution with arguments (sanitized if sensitive)
+  - ✅ DO: Log successful completion with result summary
+  - ✅ DO: Log all error conditions with appropriate log levels
+  - ✅ DO: Include the cache status in result logs
+  - ❌ DON'T: Log entire large data structures or sensitive information
+
+- The MCP server integrates with Task Master core functions through three layers:
+  1. Tool Definitions (`mcp-server/src/tools/*.js`) - Define parameters and validation
+  2. Direct Functions (`mcp-server/src/core/direct-functions/*.js`) - Handle core logic integration
+  3. Core Functions (`scripts/modules/*.js`) - Implement the actual functionality
+
+- This layered approach provides:
+  - Clear separation of concerns
+  - Consistent parameter validation
+  - Centralized error handling
+  - Performance optimization through caching (for read operations)
+  - Standardized response formatting
+
+## MCP Naming Conventions
+
+- **Files and Directories**:
+  - ✅ DO: Use **kebab-case** for all file names: `list-tasks.js`, `set-task-status.js`
+  - ✅ DO: Use consistent directory structure: `mcp-server/src/tools/` for tool definitions, `mcp-server/src/core/direct-functions/` for direct function implementations
+
+- **JavaScript Functions**:
+  - ✅ DO: Use **camelCase** with `Direct` suffix for direct function implementations: `listTasksDirect`, `setTaskStatusDirect`
+  - ✅ DO: Use **camelCase** with `Tool` suffix for tool registration functions: `registerListTasksTool`, `registerSetTaskStatusTool`
+  - ✅ DO: Use consistent action function naming inside direct functions: `coreActionFn` or similar descriptive name
+
+- **MCP Tool Names**:
+  - ✅ DO: Use **snake_case** for tool names exposed to MCP clients: `list_tasks`, `set_task_status`, `parse_prd_document`
+  - ✅ DO: Include the core action in the tool name without redundant words: Use `list_tasks` instead of `list_all_tasks`
+
+- **Examples**:
+  - File: `list-tasks.js` 
+  - Direct Function: `listTasksDirect`
+  - Tool Registration: `registerListTasksTool`
+  - MCP Tool Name: `list_tasks`
+
+- **Mapping**:
+  - The `directFunctions` map in `task-master-core.js` maps the core function name (in camelCase) to its direct implementation:
+    ```javascript
+    export const directFunctions = {
+      list: listTasksDirect,
+      setStatus: setTaskStatusDirect,
+      // Add more functions as implemented
+    };
+    ```

.cursor/rules/new_features.mdc

@@ -25,11 +25,176 @@ 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. **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)
+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).
+
+## Critical Checklist for New Features
+
+- **Comprehensive Function Exports**:
+  - ✅ **DO**: Export **all core functions, helper functions (like `generateSubtaskPrompt`), and utility methods** needed by your new function or command from their respective modules.
+  - ✅ **DO**: **Explicitly review the module's `export { ... }` block** at the bottom of the file to ensure every required dependency (even seemingly minor helpers like `findTaskById`, `taskExists`, specific prompt generators, AI call handlers, etc.) is included.
+  - ❌ **DON'T**: Assume internal functions are already exported - **always verify**. A missing export will cause runtime errors (e.g., `ReferenceError: generateSubtaskPrompt is not defined`).
+  - **Example**: If implementing a feature that checks task existence, ensure the helper function is in exports:
+  ```javascript
+  // At the bottom of your module file:
+  export {
+    // ... existing exports ...
+    yourNewFunction,
+    taskExists,  // Helper function used by yourNewFunction
+    findTaskById, // Helper function used by yourNewFunction
+    generateSubtaskPrompt, // Helper needed by expand/add features
+    getSubtasksFromAI,     // Helper needed by expand/add features
+  };
+  ```
+
+- **Parameter Completeness and Matching**:
+  - ✅ **DO**: Pass all required parameters to functions you call within your implementation
+  - ✅ **DO**: Check function signatures before implementing calls to them
+  - ✅ **DO**: Verify that direct function parameters match their core function counterparts
+  - ✅ **DO**: When implementing a direct function for MCP, ensure it only accepts parameters that exist in the core function
+  - ✅ **DO**: Verify the expected *internal structure* of complex object parameters (like the `mcpLog` object, see mcp.mdc for the required logger wrapper pattern)
+  - ❌ **DON'T**: Add parameters to direct functions that don't exist in core functions
+  - ❌ **DON'T**: Assume default parameter values will handle missing arguments
+  - ❌ **DON'T**: Assume object parameters will work without verifying their required internal structure or methods.
+  - **Example**: When calling file generation, pass all required parameters:
+  ```javascript
+  // ✅ DO: Pass all required parameters
+  await generateTaskFiles(tasksPath, path.dirname(tasksPath));
+  
+  // ❌ DON'T: Omit required parameters
+  await generateTaskFiles(tasksPath); // Error - missing outputDir parameter
+  ```
+  
+  **Example**: Properly match direct function parameters to core function:
+  ```javascript
+  // Core function signature
+  async function expandTask(tasksPath, taskId, numSubtasks, useResearch = false, additionalContext = '', options = {}) {
+    // Implementation...
+  }
+  
+  // ✅ DO: Match direct function parameters to core function
+  export async function expandTaskDirect(args, log, context = {}) {
+    // Extract only parameters that exist in the core function
+    const taskId = parseInt(args.id, 10);
+    const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
+    const useResearch = args.research === true;
+    const additionalContext = args.prompt || '';
+    
+    // Call core function with matched parameters
+    const result = await expandTask(
+      tasksPath,
+      taskId,
+      numSubtasks,
+      useResearch,
+      additionalContext,
+      { mcpLog: log, session: context.session }
+    );
+    
+    // Return result
+    return { success: true, data: result, fromCache: false };
+  }
+  
+  // ❌ DON'T: Use parameters that don't exist in the core function
+  export async function expandTaskDirect(args, log, context = {}) {
+    // DON'T extract parameters that don't exist in the core function!
+    const force = args.force === true; // ❌ WRONG - 'force' doesn't exist in core function
+    
+    // DON'T pass non-existent parameters to core functions
+    const result = await expandTask(
+      tasksPath,
+      args.id,
+      args.num,
+      args.research,
+      args.prompt,
+      force, // ❌ WRONG - this parameter doesn't exist in the core function
+      { mcpLog: log }
+    );
+  }
+  ```
+
+- **Consistent File Path Handling**:
+  - ✅ DO: Use consistent file naming conventions: `task_${id.toString().padStart(3, '0')}.txt`
+  - ✅ DO: Use `path.join()` for composing file paths
+  - ✅ DO: Use appropriate file extensions (.txt for tasks, .json for data)
+  - ❌ DON'T: Hardcode path separators or inconsistent file extensions
+  - **Example**: Creating file paths for tasks:
+  ```javascript
+  // ✅ DO: Use consistent file naming and path.join
+  const taskFileName = path.join(
+    path.dirname(tasksPath), 
+    `task_${taskId.toString().padStart(3, '0')}.txt`
+  );
+  
+  // ❌ DON'T: Use inconsistent naming or string concatenation 
+  const taskFileName = path.dirname(tasksPath) + '/' + taskId + '.md';
+  ```
+
+- **Error Handling and Reporting**:
+  - ✅ DO: Use structured error objects with code and message properties
+  - ✅ DO: Include clear error messages identifying the specific problem
+  - ✅ DO: Handle both function-specific errors and potential file system errors
+  - ✅ DO: Log errors at appropriate severity levels
+  - **Example**: Structured error handling in core functions:
+  ```javascript
+  try {
+    // Implementation...
+  } catch (error) {
+    log('error', `Error removing task: ${error.message}`);
+    throw {
+      code: 'REMOVE_TASK_ERROR',
+      message: error.message,
+      details: error.stack
+    };
+  }
+  ```
+
+- **Silent Mode Implementation**:
+  - ✅ **DO**: Import all silent mode utilities together:
+    ```javascript
+    import { enableSilentMode, disableSilentMode, isSilentMode } from '../../../../scripts/modules/utils.js';
+    ```
+  - ✅ **DO**: Always use `isSilentMode()` function to check global silent mode status, never reference global variables.
+  - ✅ **DO**: Wrap core function calls **within direct functions** using `enableSilentMode()` and `disableSilentMode()` in a `try/finally` block if the core function might produce console output (like banners, spinners, direct `console.log`s) that isn't reliably controlled by an `outputFormat` parameter.
+    ```javascript
+    // Direct Function Example:
+    try {
+      // Prefer passing 'json' if the core function reliably handles it
+      const result = await coreFunction(...args, 'json'); 
+      // OR, if outputFormat is not enough/unreliable:
+      // enableSilentMode(); // Enable *before* the call
+      // const result = await coreFunction(...args);
+      // disableSilentMode(); // Disable *after* the call (typically in finally)
+
+      return { success: true, data: result };
+    } catch (error) {
+       log.error(`Error: ${error.message}`);
+       return { success: false, error: { message: error.message } };
+    } finally {
+       // If you used enable/disable, ensure disable is called here
+       // disableSilentMode(); 
+    }
+    ```
+  - ✅ **DO**: Core functions themselves *should* ideally check `outputFormat === 'text'` before displaying UI elements (banners, spinners, boxes) and use internal logging (`log`/`report`) that respects silent mode. The `enable/disableSilentMode` wrapper in the direct function is a safety net.
+  - ✅ **DO**: Handle mixed parameter/global silent mode correctly for functions accepting both (less common now, prefer `outputFormat`):
+    ```javascript
+    // Check both the passed parameter and global silent mode
+    const isSilent = silentMode || (typeof silentMode === 'undefined' && isSilentMode());
+    ```
+  - ❌ **DON'T**: Forget to disable silent mode in a `finally` block if you enabled it.
+  - ❌ **DON'T**: Access the global `silentMode` flag directly.
+
+- **Debugging Strategy**:
+  - ✅ **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.
 
 ```javascript
 // 1. CORE LOGIC: Add function to appropriate module (example in task-manager.js)
@@ -52,7 +217,29 @@ export {
 ```
 
 ```javascript
-// 2. UI COMPONENTS: Add display function to ui.js
+// 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
 /**
  * Display archive operation results
  * @param {string} archivePath - Path to the archive file
@@ -73,7 +260,7 @@ export {
 ```
 
 ```javascript
-// 3. COMMAND INTEGRATION: Add to commands.js
+// 4. COMMAND INTEGRATION: Add to commands.js
 import { archiveTasks } from './task-manager.js';
 import { displayArchiveResults } from './ui.js';
 
@@ -293,7 +480,7 @@ npm test
 For each new feature:
 
 1. Add help text to the command definition
-2. Update [`dev_workflow.mdc`](mdc:scripts/modules/dev_workflow.mdc) with command reference
+2. Update [`dev_workflow.mdc`](mdc:.cursor/rules/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:
@@ -312,48 +499,132 @@ For more information on module structure, see [`MODULE_PLAN.md`](mdc:scripts/mod
 
 ## Adding MCP Server Support for Commands
 
-Integrating Task Master commands with the MCP server (for use by tools like Cursor) follows a specific pattern distinct from the CLI command implementation.
+Integrating Task Master commands with the MCP server (for use by tools like Cursor) follows a specific pattern distinct from the CLI command implementation, prioritizing performance and reliability.
 
-- **Goal**: Leverage direct function calls for performance and reliability, avoiding CLI overhead.
+- **Goal**: Leverage direct function calls to core logic, avoiding CLI overhead.
 - **Reference**: See [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) for full details.
 
 **MCP Integration Workflow**:
 
-1.  **Core Logic**: Ensure the command's core logic exists in the appropriate module (e.g., [`task-manager.js`](mdc:scripts/modules/task-manager.js)).
-2.  **Direct Function Wrapper**:
-    - In [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js), create an `async function yourCommandDirect(args, log)`.
-    - This function imports and calls the core logic.
-    - It uses utilities like `findTasksJsonPath` if needed.
-    - It handles argument parsing and validation specific to the direct call.
-    - **Implement Caching (if applicable)**: For read operations that benefit from caching, use the `getCachedOrExecute` utility here to wrap the core logic call. Generate a unique cache key based on relevant arguments.
-    - It returns a standard `{ success: true/false, data/error, fromCache: boolean }` object.
-    - Export the function and add it to the `directFunctions` map.
-3.  **MCP Tool File**:
-    - Create a new file in `mcp-server/src/tools/` (e.g., `yourCommand.js`).
-    - Import `zod`, `executeMCPToolAction` from `./utils.js`, and your `yourCommandDirect` function.
-    - Implement `registerYourCommandTool(server)` which calls `server.addTool`:
-        - Define the tool `name`, `description`, and `parameters` using `zod`. Include optional `projectRoot` and `file` if relevant, following patterns in existing tools.
-        - Define the `async execute(args, log)` method for the tool.
-        - **Crucially**, the `execute` method should primarily call `executeMCPToolAction`:
-          ```javascript
-          // In mcp-server/src/tools/yourCommand.js
-          import { executeMCPToolAction } from "./utils.js";
-          import { yourCommandDirect } from "../core/task-master-core.js";
-          import { z } from "zod";
+1.  **Core Logic**: Ensure the command's core logic exists and is exported from the appropriate module (e.g., [`task-manager.js`](mdc:scripts/modules/task-manager.js)).
+2.  **Direct Function Wrapper (`mcp-server/src/core/direct-functions/`)**:
+    - Create a new file (e.g., `your-command.js`) in `mcp-server/src/core/direct-functions/` using **kebab-case** naming.
+    - Import the core logic function, necessary MCP utilities like **`findTasksJsonPath` from `../utils/path-utils.js`**, and **silent mode utilities**: `import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';`
+    - Implement an `async function yourCommandDirect(args, log)` using **camelCase** with `Direct` suffix.
+    - **Path Finding**: Inside this function, obtain the `tasksPath` by calling `const tasksPath = findTasksJsonPath(args, log);`. This relies on `args.projectRoot` (derived from the session) being passed correctly.
+    - Perform validation on other arguments received in `args`.
+    - **Implement Silent Mode**: Wrap core function calls with `enableSilentMode()` and `disableSilentMode()` to prevent logs from interfering with JSON responses.
+    - **If Caching**: Implement caching using `getCachedOrExecute` from `../../tools/utils.js`.
+    - **If Not Caching**: Directly call the core logic function within a try/catch block.
+    - Format the return as `{ success: true/false, data/error, fromCache: boolean }`.
+    - Export the wrapper function.
 
-          export function registerYourCommandTool(server) {
-            server.addTool({
-              name: "yourCommand",
-              description: "Description of your command.",
-              parameters: z.object({ /* zod schema */ }),
-              async execute(args, log) {
-                return executeMCPToolAction({
-                  actionFn: yourCommandDirect, // Pass the direct function wrapper
-                  args, log, actionName: "Your Command Description"
+3.  **Update `task-master-core.js` with Import/Export**: Import and re-export your `*Direct` function and add it to the `directFunctions` map.
+
+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.
+    - 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);
+      })
+      ```
+
+5.  **Register Tool**: Import and call `registerYourCommandTool` in `mcp-server/src/tools/index.js`.
+
+6.  **Update `mcp.json`**: Add the new tool definition to the `tools` array in `.cursor/mcp.json`.
+
+## Implementing Background Operations
+
+For long-running operations that should not block the client, use the AsyncOperationManager:
+
+1. **Identify Background-Appropriate Operations**:
+   - ✅ **DO**: Use async operations for CPU-intensive tasks like task expansion or PRD parsing
+   - ✅ **DO**: Consider async operations for tasks that may take more than 1-2 seconds
+   - ❌ **DON'T**: Use async operations for quick read/status operations
+   - ❌ **DON'T**: Use async operations when immediate feedback is critical
+
+2. **Use AsyncOperationManager in MCP Tools**:
+   ```javascript
+   import { asyncOperationManager } from '../core/utils/async-manager.js';
+   
+   // In execute method:
+   const operationId = asyncOperationManager.addOperation(
+     expandTaskDirect, // The direct function to run in background
+     { ...args, projectRoot: rootFolder }, // Args to pass to the function
+     { log, reportProgress, session } // Context to preserve for the operation
+   );
+   
+   // Return immediate response with operation ID
+   return createContentResponse({
+     message: "Operation started successfully",
+     operationId,
+     status: "pending"
    });
+   ```
+
+3. **Implement Progress Reporting**:
+   - ✅ **DO**: Use the reportProgress function in direct functions:
+   ```javascript
+   // In your direct function:
+   if (reportProgress) {
+     await reportProgress({ progress: 50 }); // 50% complete
+   }
+   ```
+   - AsyncOperationManager will forward progress updates to the client
+
+4. **Check Operation Status**:
+   - Implement a way for clients to check status using the `get_operation_status` MCP tool
+   - Return appropriate status codes and messages
+
+## Project Initialization
+
+When implementing project initialization commands:
+
+1. **Support Programmatic Initialization**:
+   - ✅ **DO**: Design initialization to work with both CLI and MCP
+   - ✅ **DO**: Support non-interactive modes with sensible defaults
+   - ✅ **DO**: Handle project metadata like name, description, version
+   - ✅ **DO**: Create necessary files and directories
+
+2. **In MCP Tool Implementation**:
+   ```javascript
+   // In initialize-project.js MCP tool:
+   import { z } from "zod";
+   import { initializeProjectDirect } from "../core/task-master-core.js";
+   
+   export function registerInitializeProjectTool(server) {
+     server.addTool({
+       name: "initialize_project",
+       description: "Initialize a new Task Master project",
+       parameters: z.object({
+         projectName: z.string().optional().describe("The name for the new project"),
+         projectDescription: z.string().optional().describe("A brief description"),
+         projectVersion: z.string().optional().describe("Initial version (e.g., '0.1.0')"),
+         // Add other parameters as needed
+       }),
+       execute: async (args, { log, reportProgress, session }) => {
+         try {
+           // No need for project root since we're creating a new project
+           const result = await initializeProjectDirect(args, log);
+           return handleApiResult(result, log, 'Error initializing project');
+         } catch (error) {
+           log.error(`Error in initialize_project: ${error.message}`);
+           return createErrorResponse(`Failed to initialize project: ${error.message}`);
+         }
        }
      });
    }
    ```
-4.  **Register in Tool Index**: Import and call `registerYourCommandTool` in [`mcp-server/src/tools/index.js`](mdc:mcp-server/src/tools/index.js).
-5.  **Update `mcp.json`**: Add the tool definition to `.cursor/mcp.json`.

.cursor/rules/self_improve.mdc

@@ -69,5 +69,4 @@ 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

@@ -0,0 +1,382 @@
+---
+description: Comprehensive reference for Taskmaster MCP tools and CLI commands.
+globs: **/*
+alwaysApply: true
+---
+# Taskmaster Tool & Command Reference
+
+This document provides a detailed reference for interacting with Taskmaster, covering both the recommended MCP tools, suitable for integrations like Cursor, and the corresponding `task-master` CLI commands, designed for direct user interaction or fallback.
+
+**Note:** For interacting with Taskmaster programmatically or via integrated tools, using the **MCP tools is strongly recommended** due to better performance, structured data, and error handling. The CLI commands serve as a user-friendly alternative and fallback. 
+
+**Important:** Several MCP tools involve AI processing... The AI-powered tools include `parse_prd`, `analyze_project_complexity`, `update_subtask`, `update_task`, `update`, `expand_all`, `expand_task`, and `add_task`.
+
+---
+
+## Initialization & Setup
+
+### 1. Initialize Project (`init`)
+
+*   **MCP Tool:** `initialize_project`
+*   **CLI Command:** `task-master init [options]`
+*   **Description:** `Set up the basic Taskmaster file structure and configuration in the current directory for a new project.`
+*   **Key CLI Options:**
+    *   `--name <name>`: `Set the name for your project in Taskmaster's configuration.`
+    *   `--description <text>`: `Provide a brief description for your project.`
+    *   `--version <version>`: `Set the initial version for your project, e.g., '0.1.0'.`
+    *   `-y, --yes`: `Initialize Taskmaster quickly using default settings without interactive prompts.`
+*   **Usage:** Run this once at the beginning of a new project.
+*   **MCP Variant Description:** `Set up the basic Taskmaster file structure and configuration in the current directory for a new project by running the 'task-master init' command.`
+*   **Key MCP Parameters/Options:**
+    *   `projectName`: `Set the name for your project.` (CLI: `--name <name>`)
+    *   `projectDescription`: `Provide a brief description for your project.` (CLI: `--description <text>`)
+    *   `projectVersion`: `Set the initial version for your project, e.g., '0.1.0'.` (CLI: `--version <version>`)
+    *   `authorName`: `Author name.` (CLI: `--author <author>`)
+    *   `skipInstall`: `Skip installing dependencies. Default is false.` (CLI: `--skip-install`)
+    *   `addAliases`: `Add shell aliases tm and taskmaster. Default is false.` (CLI: `--aliases`)
+    *   `yes`: `Skip prompts and use defaults/provided arguments. Default is false.` (CLI: `-y, --yes`)
+*   **Usage:** Run this once at the beginning of a new project, typically via an integrated tool like Cursor. Operates on the current working directory of the MCP server. 
+*   **Important:** Once complete, you *MUST* parse a prd in order to generate tasks. There will be no tasks files until then. The next step after initializing should be to create a PRD using the example PRD in 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.`
+*   **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>`)
+    *   `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.
+
+---
+
+## Task Listing & Viewing
+
+### 3. Get Tasks (`get_tasks`)
+
+*   **MCP Tool:** `get_tasks`
+*   **CLI Command:** `task-master list [options]`
+*   **Description:** `List your Taskmaster tasks, optionally filtering by status and showing subtasks.`
+*   **Key Parameters/Options:**
+    *   `status`: `Show only Taskmaster tasks matching this status, e.g., 'pending' or '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>`)
+*   **Usage:** Get an overview of the project status, often used at the start of a work session.
+
+### 4. Get Next Task (`next_task`)
+
+*   **MCP Tool:** `next_task`
+*   **CLI Command:** `task-master next [options]`
+*   **Description:** `Ask Taskmaster to show the next available task you can work on, based on status and completed dependencies.`
+*   **Key Parameters/Options:**
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Identify what to work on next according to the plan.
+
+### 5. Get Task Details (`get_task`)
+
+*   **MCP Tool:** `get_task`
+*   **CLI Command:** `task-master show [id] [options]`
+*   **Description:** `Display detailed information for 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>`)
+*   **Usage:** Understand the full details, implementation notes, and test strategy for a specific task before starting work.
+
+---
+
+## Task Creation & Modification
+
+### 6. Add Task (`add_task`)
+
+*   **MCP Tool:** `add_task`
+*   **CLI Command:** `task-master add-task [options]`
+*   **Description:** `Add a new task to Taskmaster by describing it; AI will structure it.`
+*   **Key Parameters/Options:**
+    *   `prompt`: `Required. Describe the new task you want Taskmaster to create, e.g., "Implement user authentication using JWT".` (CLI: `-p, --prompt <text>`)
+    *   `dependencies`: `Specify the IDs of any Taskmaster tasks that must be completed before this new one can start, e.g., '12,14'.` (CLI: `-d, --dependencies <ids>`)
+    *   `priority`: `Set the priority for the new task: 'high', 'medium', or 'low'. Default is 'medium'.` (CLI: `--priority <priority>`)
+    *   `research`: `Enable Taskmaster to use the research role for potentially more informed task creation.` (CLI: `-r, --research`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Quickly add newly identified tasks during development.
+*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
+
+### 7. Add Subtask (`add_subtask`)
+
+*   **MCP Tool:** `add_subtask`
+*   **CLI Command:** `task-master add-subtask [options]`
+*   **Description:** `Add a new subtask to a Taskmaster parent task, or convert an existing task into a subtask.`
+*   **Key Parameters/Options:**
+    *   `id` / `parent`: `Required. The ID of the Taskmaster task that will be the parent.` (MCP: `id`, CLI: `-p, --parent <id>`)
+    *   `taskId`: `Use this if you want to convert an existing top-level Taskmaster task into a subtask of the specified parent.` (CLI: `-i, --task-id <id>`)
+    *   `title`: `Required if not using taskId. The title for the new subtask Taskmaster should create.` (CLI: `-t, --title <title>`)
+    *   `description`: `A brief description for the new subtask.` (CLI: `-d, --description <text>`)
+    *   `details`: `Provide implementation notes or details for the new subtask.` (CLI: `--details <text>`)
+    *   `dependencies`: `Specify IDs of other tasks or subtasks, e.g., '15' or '16.1', that must be done before this new subtask.` (CLI: `--dependencies <ids>`)
+    *   `status`: `Set the initial status for the new subtask. Default is 'pending'.` (CLI: `-s, --status <status>`)
+    *   `skipGenerate`: `Prevent Taskmaster from automatically regenerating markdown task files after adding the subtask.` (CLI: `--skip-generate`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Break down tasks manually or reorganize existing tasks.
+
+### 8. Update Tasks (`update`)
+
+*   **MCP Tool:** `update`
+*   **CLI Command:** `task-master update [options]`
+*   **Description:** `Update multiple upcoming tasks in Taskmaster based on new context or changes, starting from a specific task ID.`
+*   **Key Parameters/Options:**
+    *   `from`: `Required. The ID of the first task Taskmaster should update. All tasks with this ID or higher that are not 'done' will be considered.` (CLI: `--from <id>`)
+    *   `prompt`: `Required. Explain the change or new context for Taskmaster to apply to the tasks, e.g., "We are now using React Query instead of Redux Toolkit for data fetching".` (CLI: `-p, --prompt <text>`)
+    *   `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Handle significant implementation changes or pivots that affect multiple future tasks. Example CLI: `task-master update --from='18' --prompt='Switching to React Query.\nNeed to refactor data fetching...'`
+*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
+
+### 9. Update Task (`update_task`)
+
+*   **MCP Tool:** `update_task`
+*   **CLI Command:** `task-master update-task [options]`
+*   **Description:** `Modify a specific Taskmaster task 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>`)
+    *   `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>`)
+*   **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.
+
+### 10. Update Subtask (`update_subtask`)
+
+*   **MCP Tool:** `update_subtask`
+*   **CLI Command:** `task-master update-subtask [options]`
+*   **Description:** `Append timestamped notes or details to a specific Taskmaster subtask without overwriting existing content. Intended for iterative implementation logging.`
+*   **Key Parameters/Options:**
+    *   `id`: `Required. The 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>`)
+*   **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.
+
+### 11. Set Task Status (`set_task_status`)
+
+*   **MCP Tool:** `set_task_status`
+*   **CLI Command:** `task-master set-status [options]`
+*   **Description:** `Update the status of one or more Taskmaster tasks or subtasks, e.g., 'pending', 'in-progress', 'done'.`
+*   **Key Parameters/Options:**
+    *   `id`: `Required. The ID(s) of the Taskmaster task(s) or subtask(s), e.g., '15', '15.2', or '16,17.1', to update.` (CLI: `-i, --id <id>`)
+    *   `status`: `Required. The new status to set, e.g., 'done', 'pending', 'in-progress', 'review', 'cancelled'.` (CLI: `-s, --status <status>`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Mark progress as tasks move through the development cycle.
+
+### 12. Remove Task (`remove_task`)
+
+*   **MCP Tool:** `remove_task`
+*   **CLI Command:** `task-master remove-task [options]`
+*   **Description:** `Permanently remove a task or subtask from the Taskmaster tasks list.`
+*   **Key Parameters/Options:**
+    *   `id`: `Required. The ID of the Taskmaster task, e.g., '5', or subtask, e.g., '5.2', to permanently remove.` (CLI: `-i, --id <id>`)
+    *   `yes`: `Skip the confirmation prompt and immediately delete the task.` (CLI: `-y, --yes`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Permanently delete tasks or subtasks that are no longer needed in the project.
+*   **Notes:** Use with caution as this operation cannot be undone. Consider using 'blocked', 'cancelled', or 'deferred' status instead if you just want to exclude a task from active planning but keep it for reference. The command automatically cleans up dependency references in other tasks.
+
+---
+
+## Task Structure & Breakdown
+
+### 13. Expand Task (`expand_task`)
+
+*   **MCP Tool:** `expand_task`
+*   **CLI Command:** `task-master expand [options]`
+*   **Description:** `Use Taskmaster's AI to break down a complex task into smaller, manageable subtasks. Appends subtasks by default.`
+*   **Key Parameters/Options:**
+    *   `id`: `The ID of the specific Taskmaster task you want to break down into subtasks.` (CLI: `-i, --id <id>`)
+    *   `num`: `Optional: Suggests how many subtasks Taskmaster should aim to create. Uses complexity analysis/defaults otherwise.` (CLI: `-n, --num <number>`)
+    *   `research`: `Enable Taskmaster to use the research role for more informed subtask generation. Requires appropriate API key.` (CLI: `-r, --research`)
+    *   `prompt`: `Optional: Provide extra context or specific instructions to Taskmaster for generating the subtasks.` (CLI: `-p, --prompt <text>`)
+    *   `force`: `Optional: If true, clear existing subtasks before generating new ones. Default is false (append).` (CLI: `--force`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Generate a detailed implementation plan for a complex task before starting coding. Automatically uses complexity report recommendations if available and `num` is not specified.
+*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
+
+### 14. Expand All Tasks (`expand_all`)
+
+*   **MCP Tool:** `expand_all`
+*   **CLI Command:** `task-master expand --all [options]` (Note: CLI uses the `expand` command with the `--all` flag)
+*   **Description:** `Tell Taskmaster to automatically expand all eligible pending/in-progress tasks based on complexity analysis or defaults. Appends subtasks by default.`
+*   **Key Parameters/Options:**
+    *   `num`: `Optional: Suggests how many subtasks Taskmaster should aim to create per task.` (CLI: `-n, --num <number>`)
+    *   `research`: `Enable research role for more informed subtask generation. Requires appropriate API key.` (CLI: `-r, --research`)
+    *   `prompt`: `Optional: Provide extra context for Taskmaster to apply generally during expansion.` (CLI: `-p, --prompt <text>`)
+    *   `force`: `Optional: If true, clear existing subtasks before generating new ones for each eligible task. Default is false (append).` (CLI: `--force`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Useful after initial task generation or complexity analysis to break down multiple tasks at once.
+*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
+
+### 15. Clear Subtasks (`clear_subtasks`)
+
+*   **MCP Tool:** `clear_subtasks`
+*   **CLI Command:** `task-master clear-subtasks [options]`
+*   **Description:** `Remove all subtasks from one or more specified Taskmaster parent tasks.`
+*   **Key Parameters/Options:**
+    *   `id`: `The ID(s) of the Taskmaster parent task(s) whose subtasks you want to remove, e.g., '15' or '16,18'. Required unless using `all`.) (CLI: `-i, --id <ids>`)
+    *   `all`: `Tell Taskmaster to remove subtasks from all parent tasks.` (CLI: `--all`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Used before regenerating subtasks with `expand_task` if the previous breakdown needs replacement.
+
+### 16. Remove Subtask (`remove_subtask`)
+
+*   **MCP Tool:** `remove_subtask`
+*   **CLI Command:** `task-master remove-subtask [options]`
+*   **Description:** `Remove a subtask from its Taskmaster parent, optionally converting it into a standalone task.`
+*   **Key Parameters/Options:**
+    *   `id`: `Required. The ID(s) of the Taskmaster subtask(s) to remove, e.g., '15.2' or '16.1,16.3'.` (CLI: `-i, --id <id>`)
+    *   `convert`: `If used, Taskmaster will turn the subtask into a regular top-level task instead of deleting it.` (CLI: `-c, --convert`)
+    *   `skipGenerate`: `Prevent Taskmaster from automatically regenerating markdown task files after removing the subtask.` (CLI: `--skip-generate`)
+    *   `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.
+
+---
+
+## Dependency Management
+
+### 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>`)
+*   **Usage:** Establish the correct order of execution between tasks.
+
+### 18. Remove Dependency (`remove_dependency`)
+
+*   **MCP Tool:** `remove_dependency`
+*   **CLI Command:** `task-master remove-dependency [options]`
+*   **Description:** `Remove a dependency relationship between two Taskmaster tasks.`
+*   **Key Parameters/Options:**
+    *   `id`: `Required. The ID of the Taskmaster task you want to remove a prerequisite from.` (CLI: `-i, --id <id>`)
+    *   `dependsOn`: `Required. The ID of the Taskmaster task that should no longer be a prerequisite.` (CLI: `-d, --depends-on <id>`)
+    *   `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.
+
+### 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>`)
+*   **Usage:** Audit the integrity of your task 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>`)
+*   **Usage:** Clean up dependency errors automatically.
+
+---
+
+## Analysis & Reporting
+
+### 21. Analyze Project Complexity (`analyze_project_complexity`)
+
+*   **MCP Tool:** `analyze_project_complexity`
+*   **CLI Command:** `task-master analyze-complexity [options]`
+*   **Description:** `Have Taskmaster analyze your tasks to determine their complexity and suggest which ones need to be broken down further.`
+*   **Key Parameters/Options:**
+    *   `output`: `Where to save the complexity analysis report (default: '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>`)
+*   **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.
+
+### 22. View Complexity Report (`complexity_report`)
+
+*   **MCP Tool:** `complexity_report`
+*   **CLI Command:** `task-master complexity-report [options]`
+*   **Description:** `Display the task complexity analysis report in a readable format.`
+*   **Key Parameters/Options:**
+    *   `file`: `Path to the complexity report (default: 'scripts/task-complexity-report.json').` (CLI: `-f, --file <file>`)
+*   **Usage:** Review and understand the complexity analysis results after running analyze-complexity.
+
+---
+
+## File Management
+
+### 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>`)
+*   **Usage:** Run this after making changes to tasks.json to keep individual task files up to date.
+
+---
+
+## Environment Variables Configuration (Updated)
+
+Taskmaster primarily uses the **`.taskmasterconfig`** file (in project root) for configuration (models, parameters, logging level, etc.), managed via `task-master models --setup`.
+
+Environment variables are used **only** for sensitive API keys related to AI providers and specific overrides like the Ollama base URL:
+
+*   **API Keys (Required for corresponding provider):**
+    *   `ANTHROPIC_API_KEY`
+    *   `PERPLEXITY_API_KEY`
+    *   `OPENAI_API_KEY`
+    *   `GOOGLE_API_KEY`
+    *   `MISTRAL_API_KEY`
+    *   `AZURE_OPENAI_API_KEY` (Requires `AZURE_OPENAI_ENDPOINT` too)
+    *   `OPENROUTER_API_KEY`
+    *   `XAI_API_KEY`
+    *   `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.
+
+---
+
+For details on how these commands fit into the development process, see the [Development Workflow Guide](mdc:.cursor/rules/dev_workflow.mdc).

.cursor/rules/tests.mdc

@@ -5,6 +5,8 @@ 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)
@@ -88,6 +90,122 @@ 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**
@@ -165,107 +283,97 @@ 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 Entire Modules**
-  ```javascript
-  // 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');
+- **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.
 
-    // Return mix of original and mocked functionality
-    return {
-      ...originalModule,
-      generateTaskFiles: jest.fn() // Replace specific functions
-    };
+- **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.
+  ```javascript
+  // 1. Define mock function instances
+  const mockExistsSync = jest.fn();
+  const mockReadFileSync = jest.fn();
+  // ... other mocks
+
+  // 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');
   });
 
-  // Import after mocks
-  import * as taskManager from '../../scripts/modules/task-manager.js';
+  // 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.
 
-  // Now you can use the mock directly
-  const { generateTaskFiles } = taskManager;
+- **Mocking Entire Modules (Static Import)**
+  ```javascript
+  // Mock the entire module with custom implementation for static imports
+  // ... (existing example remains valid) ...
   ```
 
 - **Direct Implementation Testing**
   - Instead of calling the actual function which may have module-scope reference issues:
   ```javascript
-  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');
-  });
+  // ... (existing example remains valid) ...
   ```
 
 - **Avoiding Module Property Assignment**
   ```javascript
-  // ❌ 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
-  }));
+  // ... (existing example remains valid) ...
   ```
 
 - **Handling Mock Verification Failures**
   - If verification like `expect(mockFn).toHaveBeenCalled()` fails:
-    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**
+    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
-  // 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');
-    });
-  });
+        // 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.
 
 ## Mocking Guidelines
 
@@ -552,6 +660,102 @@ 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**
@@ -564,99 +768,125 @@ npm test -- -t "pattern to match"
   const setTaskStatus = async (taskId, newStatus) => {
     const tasksPath = 'tasks/tasks.json';
     const data = await readJSON(tasksPath);
-    // Update task status logic
+    // [implementation]
     await writeJSON(tasksPath, data);
-    return data;
+    return { success: true };
   };
   
-  // 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
+  // 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 };
   };
   ```
 
-- **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,7 +3,6 @@ description: Guidelines for implementing utility functions
 globs: scripts/modules/utils.js, mcp-server/src/**/*
 alwaysApply: false
 ---
-
 # Utility Function Guidelines
 
 ## General Principles
@@ -44,6 +43,12 @@ alwaysApply: false
   }
   ```
 
+- **Location**:
+    - **Core CLI Utilities**: Place utilities used primarily by the core `task-master` CLI logic and command modules (`scripts/modules/*`) into [`scripts/modules/utils.js`](mdc:scripts/modules/utils.js).
+    - **MCP Server Utilities**: Place utilities specifically designed to support the MCP server implementation into the appropriate subdirectories within `mcp-server/src/`.
+        - Path/Core Logic Helpers: [`mcp-server/src/core/utils/`](mdc:mcp-server/src/core/utils/) (e.g., `path-utils.js`).
+        - Tool Execution/Response Helpers: [`mcp-server/src/tools/utils.js`](mdc:mcp-server/src/tools/utils.js).
+
 ## Documentation Standards
 
 - **JSDoc Format**:
@@ -73,36 +78,61 @@ alwaysApply: false
   }
   ```
 
-## Configuration Management
+## Configuration Management (via `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
+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).
 
-  ```javascript
-  // ✅ DO: Set up configuration with defaults and environment overrides
-  const CONFIG = {
-    model: process.env.MODEL || 'claude-3-7-sonnet-20250219',
-    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",
-    projectVersion: "1.5.0" // Version should be hardcoded
-  };
-  ```
+- **`.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.
 
-## Logging Utilities
+- **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).
+
+## Logging Utilities (in `scripts/modules/utils.js`)
 
 - **Log Levels**:
   - ✅ DO: Support multiple log levels (debug, info, warn, error)
   - ✅ DO: Use appropriate icons for different log levels
   - ✅ DO: Respect the configured log level
   - ❌ DON'T: Add direct console.log calls outside the logging utility
+  - **Note on Passed Loggers**: When a logger object (like the FastMCP `log` object) is passed *as a parameter* (e.g., as `mcpLog`) into core Task Master functions, the receiving function often expects specific methods (`.info`, `.warn`, `.error`, etc.) to be directly callable on that object (e.g., `mcpLog[level](...)`). If the passed logger doesn't have this exact structure, a wrapper object may be needed. See the **Handling Logging Context (`mcpLog`)** section in [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) for the standard pattern used in direct functions.
+
+- **Logger Wrapper Pattern**: 
+  - ✅ DO: Use the logger wrapper pattern when passing loggers to prevent `mcpLog[level] is not a function` errors:
+  ```javascript
+  // Standard logWrapper pattern to wrap FastMCP's log object
+  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
+  };
+  
+  // Pass this wrapper as mcpLog to ensure consistent method availability
+  // This also ensures output format is set to 'json' in many core functions
+  const options = { mcpLog: logWrapper, session };
+  ```
+  - ✅ DO: Implement this pattern in any direct function that calls core functions expecting `mcpLog`
+  - ✅ DO: Use this solution in conjunction with silent mode for complete output control
+  - ❌ DON'T: Pass the FastMCP `log` object directly as `mcpLog` to core functions
+  - **Important**: This pattern has successfully fixed multiple issues in MCP tools (e.g., `update-task`, `update-subtask`) where using or omitting `mcpLog` incorrectly led to runtime errors or JSON parsing failures.
+  - For complete implementation details, see the **Handling Logging Context (`mcpLog`)** section in [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc).
 
   ```javascript
   // ✅ DO: Implement a proper logging utility
@@ -129,18 +159,124 @@ alwaysApply: false
   }
   ```
 
-## File Operations
+## Silent Mode Utilities (in `scripts/modules/utils.js`)
+
+- **Silent Mode Control**:
+  - ✅ DO: Use the exported silent mode functions rather than accessing global variables
+  - ✅ DO: Always use `isSilentMode()` to check the current silent mode state
+  - ✅ DO: Ensure silent mode is disabled in a `finally` block to prevent it from staying enabled
+  - ❌ DON'T: Access the global `silentMode` variable directly
+  - ❌ DON'T: Forget to disable silent mode after enabling it
+
+  ```javascript
+  // ✅ DO: Use the silent mode control functions properly
+  
+  // Example of proper implementation in utils.js:
+  
+  // Global silent mode flag (private to the module)
+  let silentMode = false;
+  
+  // Enable silent mode
+  function enableSilentMode() {
+    silentMode = true;
+  }
+  
+  // Disable silent mode
+  function disableSilentMode() {
+    silentMode = false;
+  }
+  
+  // Check if silent mode is enabled
+  function isSilentMode() {
+    return silentMode;
+  }
+  
+  // Example of proper usage in another module:
+  import { enableSilentMode, disableSilentMode, isSilentMode } from './utils.js';
+  
+  // Check current status
+  if (!isSilentMode()) {
+    console.log('Silent mode is not enabled');
+  }
+  
+  // Use try/finally pattern to ensure silent mode is disabled
+  try {
+    enableSilentMode();
+    // Do something that should suppress console output
+    performOperation();
+  } finally {
+    disableSilentMode();
+  }
+  ```
+
+- **Integration with Logging**:
+  - ✅ DO: Make the `log` function respect silent mode
+  ```javascript
+  function log(level, ...args) {
+    // Skip logging if silent mode is enabled
+    if (isSilentMode()) {
+      return;
+    }
+    
+    // Rest of logging logic...
+  }
+  ```
+
+- **Common Patterns for Silent Mode**:
+  - ✅ DO: In **direct functions** (`mcp-server/src/core/direct-functions/*`) that call **core functions** (`scripts/modules/*`), ensure console output from the core function is suppressed to avoid breaking MCP JSON responses.
+    - **Preferred Method**: Update the core function to accept an `outputFormat` parameter (e.g., `outputFormat = 'text'`) and make it check `outputFormat === 'text'` before displaying any UI elements (banners, spinners, boxes, direct `console.log`s). Pass `'json'` from the direct function.
+    - **Necessary Fallback/Guarantee**: If the core function *cannot* be modified or its output suppression via `outputFormat` is unreliable, **wrap the core function call within the direct function** using `enableSilentMode()` and `disableSilentMode()` in a `try/finally` block. This acts as a safety net.
+  ```javascript
+  // Example in a direct function
+  export async function someOperationDirect(args, log) {
+    let result;
+    const tasksPath = findTasksJsonPath(args, log); // Get path first
+    
+    // Option 1: Core function handles 'json' format (Preferred)
+    try {
+      result = await coreFunction(tasksPath, ...otherArgs, 'json'); // Pass 'json'
+      return { success: true, data: result, fromCache: false };
+    } catch (error) {
+      // Handle error...
+    }
+
+    // Option 2: Core function output unreliable (Fallback/Guarantee)
+    try {
+      enableSilentMode(); // Enable before call
+      result = await coreFunction(tasksPath, ...otherArgs); // Call without format param
+    } catch (error) {
+      // Handle error...
+      log.error(`Failed: ${error.message}`);
+      return { success: false, error: { /* ... */ } };
+    } finally {
+      disableSilentMode(); // ALWAYS disable in finally
+    }
+    return { success: true, data: result, fromCache: false }; // Assuming success if no error caught
+  }
+  ```
+  - ✅ DO: For functions that accept a silent mode parameter but also need to check global state (less common):
+  ```javascript
+  // Check both the passed parameter and global silent mode
+  const isSilent = options.silentMode || (typeof options.silentMode === 'undefined' && isSilentMode());
+  ```
+
+## File Operations (in `scripts/modules/utils.js`)
 
 - **Error Handling**:
   - ✅ DO: Use try/catch blocks for all file operations
   - ✅ DO: Return null or a default value on failure
-  - ✅ DO: Log detailed error information
-  - ❌ DON'T: Allow exceptions to propagate unhandled
+  - ✅ DO: Log detailed error information using the `log` utility
+  - ❌ DON'T: Allow exceptions to propagate unhandled from simple file reads/writes
 
   ```javascript
-  // ✅ DO: Handle file operation errors properly
+  // ✅ DO: Handle file operation errors properly in core utils
   function writeJSON(filepath, data) {
     try {
+      // Ensure directory exists (example)
+      const dir = path.dirname(filepath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
       fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
     } catch (error) {
       log('error', `Error writing JSON file ${filepath}:`, error.message);
@@ -151,7 +287,7 @@ alwaysApply: false
   }
   ```
 
-## Task-Specific Utilities
+## Task-Specific Utilities (in `scripts/modules/utils.js`)
 
 - **Task ID Formatting**:
   - ✅ DO: Create utilities for consistent ID handling
@@ -224,7 +360,7 @@ alwaysApply: false
   }
   ```
 
-## Cycle Detection
+## Cycle Detection (in `scripts/modules/utils.js`)
 
 - **Graph Algorithms**:
   - ✅ DO: Implement cycle detection using graph traversal
@@ -273,84 +409,101 @@ alwaysApply: false
   }
   ```
 
-## MCP Server Utilities (`mcp-server/src/tools/utils.js`)
+## MCP Server Core Utilities (`mcp-server/src/core/utils/`)
 
-- **Purpose**: These utilities specifically support the MCP server tools, handling communication patterns and data formatting for MCP clients. Refer to [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) for usage patterns.
+### Project Root and Task File Path Detection (`path-utils.js`)
 
--(See also: [`tests.mdc`](mdc:.cursor/rules/tests.mdc) for testing these utilities)
+- **Purpose**: This module ([`mcp-server/src/core/utils/path-utils.js`](mdc:mcp-server/src/core/utils/path-utils.js)) provides the mechanism for locating the user's `tasks.json` file, used by direct functions.
+- **`findTasksJsonPath(args, log)`**:
+    - ✅ **DO**: Call this function from within **direct function wrappers** (e.g., `listTasksDirect` in `mcp-server/src/core/direct-functions/`) to get the absolute path to the relevant `tasks.json`.
+    - Pass the *entire `args` object* received by the MCP tool (which should include `projectRoot` derived from the session) and the `log` object.
+    - Implements a **simplified precedence system** for finding the `tasks.json` path:
+        1.  Explicit `projectRoot` passed in `args` (Expected from MCP tools).
+        2.  Cached `lastFoundProjectRoot` (CLI fallback).
+        3.  Search upwards from `process.cwd()` (CLI fallback).
+    - Throws a specific error if the `tasks.json` file cannot be located.
+    - Updates the `lastFoundProjectRoot` cache on success.
+- **`PROJECT_MARKERS`**: An exported array of common file/directory names used to identify a likely project root during the CLI fallback search.
+- **`getPackagePath()`**: Utility to find the installation path of the `task-master-ai` package itself (potentially removable).
 
-- **`getProjectRoot(projectRootRaw, log)`**:
-  - Normalizes a potentially relative project root path into an absolute path.
-  - Defaults to `process.cwd()` if `projectRootRaw` is not provided.
-  - Primarily used *internally* by `executeMCPToolAction` and `executeTaskMasterCommand`. Tools usually don't need to call this directly.
+## MCP Server Tool Utilities (`mcp-server/src/tools/utils.js`)
 
-- **`executeMCPToolAction({ actionFn, args, log, actionName, processResult })`**:
-  - ✅ **DO**: Use this as the main wrapper inside an MCP tool's `execute` method when calling a direct function wrapper.
-  - Handles standard workflow: logs action start, normalizes `projectRoot`, calls the `actionFn` (e.g., `listTasksDirect`), processes the result (using `handleApiResult`), logs success/error, and returns a formatted MCP response (`createContentResponse`/`createErrorResponse`).
-  - Simplifies tool implementation significantly by handling boilerplate.
-  - Accepts an optional `processResult` function to customize data filtering/transformation before sending the response (defaults to `processMCPResponseData`).
+These utilities specifically support the implementation and execution of MCP tools.
 
-- **`handleApiResult(result, log, errorPrefix, processFunction)`**:
-  - Takes the standard `{ success, data/error }` object returned by direct function wrappers (like `listTasksDirect`).
-  - Checks the `success` flag.
-  - If successful, processes the `data` using `processFunction` (defaults to `processMCPResponseData`).
-  - Returns a formatted MCP response object using `createContentResponse` or `createErrorResponse`.
-  - Typically called *internally* by `executeMCPToolAction`.
+- **`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.
 
-- **`executeTaskMasterCommand(command, log, args, projectRootRaw)`**:
-  - Executes a Task Master command using `child_process.spawnSync`.
-  - Tries the global `task-master` command first, then falls back to `node scripts/dev.js`.
-  - Handles project root normalization internally.
-  - Returns `{ success, stdout, stderr }` or `{ success: false, error }`.
-  - ❌ **DON'T**: Use this as the primary method for MCP tools. Prefer `executeMCPToolAction` with direct function calls. Use only as a fallback for commands not yet refactored or those requiring CLI execution.
-
-- **`processMCPResponseData(taskOrData, fieldsToRemove = ['details', 'testStrategy'])`**:
-  - Filters task data before sending it to the MCP client.
-  - By default, removes the `details` and `testStrategy` fields from task objects and their subtasks to reduce payload size.
-  - Can handle single task objects or data structures containing a `tasks` array (like from `listTasks`).
-  - This is the default processor used by `executeMCPToolAction`.
+- **`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
-  // Example usage (typically done inside executeMCPToolAction):
-  const rawResult = { success: true, data: { tasks: [ { id: 1, title: '...', details: '...', subtasks: [...] } ] } };
-  const filteredData = processMCPResponseData(rawResult.data);
-  // filteredData.tasks[0] will NOT have the 'details' field.
+      // 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 ...
+              })
+          });
+      }
       ```
 
-- **`createContentResponse(content)`**:
-  - ✅ **DO**: Use this (usually via `handleApiResult` or `executeMCPToolAction`) to format successful MCP responses.
-  - Wraps the `content` (stringifies objects to JSON) in the standard FastMCP `{ content: [{ type: "text", text: ... }] }` structure.
+- **`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.
 
-- **`createErrorResponse(errorMessage)`**:
-  - ✅ **DO**: Use this (usually via `handleApiResult` or `executeMCPToolAction`) to format error responses for MCP.
-  - Wraps the `errorMessage` in the standard FastMCP error structure, including `isError: true`.
+- **`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 })`**:
-  - ✅ **DO**: Use this utility *inside direct function wrappers* (like `listTasksDirect` in `task-master-core.js`) to implement caching for MCP operations.
-  - Checks the `ContextManager` cache using `cacheKey`.
-  - If a hit occurs, returns the cached result directly.
-  - If a miss occurs, it executes the provided `actionFn` (which should be an async function returning `{ success, data/error }`).
-  - If `actionFn` succeeds, its result is stored in the cache under `cacheKey`.
-  - Returns the result (either cached or fresh) wrapped in the standard structure `{ success, data/error, fromCache: boolean }`.
+    - **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.
 
-- **`executeMCPToolAction({ actionFn, args, log, actionName, processResult })`**:
-  - Update: While this function *can* technically coordinate caching if provided a `cacheKeyGenerator`, the current preferred pattern involves implementing caching *within* the `actionFn` (the direct wrapper) using `getCachedOrExecute`. `executeMCPToolAction` primarily orchestrates the call to `actionFn` and handles processing its result (including the `fromCache` flag) via `handleApiResult`.
+- **`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`.
 
-- **`handleApiResult(result, log, errorPrefix, processFunction)`**:
-  - Update: Now expects the `result` object to potentially contain a `fromCache` boolean flag. If present, this flag is included in the final response payload generated by `createContentResponse` (e.g., `{ fromCache: true, data: ... }`).
+- **`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.
+
+- **`executeTaskMasterCommand(...)`**: 
+    - **Purpose**: Executes `task-master` CLI command as a fallback. 
+    - **Recommendation**: Deprecated for most uses; prefer direct function calls.
 
 ## Export Organization
 
 - **Grouping Related Functions**:
-  - ✅ DO: Keep utilities relevant to their location (e.g., core utils in `scripts/modules/utils.js`, MCP utils in `mcp-server/src/tools/utils.js`).
+  - ✅ DO: Keep utilities relevant to their location (e.g., core CLI utils in `scripts/modules/utils.js`, MCP path utils in `mcp-server/src/core/utils/path-utils.js`, MCP tool utils in `mcp-server/src/tools/utils.js`).
   - ✅ DO: Export all utility functions in a single statement per file.
   - ✅ DO: Group related exports together.
-  - ✅ DO: Export configuration constants.
+  - ✅ DO: Export configuration constants (from `scripts/modules/utils.js`).
   - ❌ DON'T: Use default exports.
-  - ❌ DON'T: Create circular dependencies between utility files or between utilities and the modules that use them (See [`architecture.mdc`](mdc:.cursor/rules/architecture.mdc)).
+  - ❌ DON'T: Create circular dependencies (See [`architecture.mdc`](mdc:.cursor/rules/architecture.mdc)).
 
 ```javascript
-  // ✅ DO: Organize exports logically
+// Example export from scripts/modules/utils.js
 export {
   // Configuration
   CONFIG,
@@ -368,15 +521,31 @@ alwaysApply: false
   truncate,
   
   // Task utilities
-    readComplexityReport,
-    findTaskInComplexityReport,
-    taskExists,
-    formatTaskId,
-    findTaskById,
+  // ... (taskExists, formatTaskId, findTaskById, etc.)
   
   // Graph algorithms
   findCycles,
 };
+
+// Example export from mcp-server/src/core/utils/path-utils.js
+export {
+  findTasksJsonPath,
+  getPackagePath,
+  PROJECT_MARKERS,
+  lastFoundProjectRoot // Exporting for potential direct use/reset if needed
+};
+
+// Example export from mcp-server/src/tools/utils.js
+export {
+  getProjectRoot,
+  getProjectRootFromSession,
+  handleApiResult,
+  executeTaskMasterCommand,
+  processMCPResponseData,
+  createContentResponse,
+  createErrorResponse,
+  getCachedOrExecute
+};
 ```
 
-Refer to [`utils.js`](mdc:scripts/modules/utils.js) for implementation examples and [`new_features.mdc`](mdc:.cursor/rules/new_features.mdc) for integration guidelines. Use [`commands.mdc`](mdc:.cursor/rules/commands.mdc) for CLI integration details. 
+Refer to [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) and [`architecture.mdc`](mdc:.cursor/rules/architecture.mdc) for more context on MCP server architecture and integration. 

.env.example

@@ -1,20 +1,9 @@
-# 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=64000                   # Maximum tokens for model responses
-TEMPERATURE=0.4                   # 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=4                # 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
+# 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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,39 @@
+---
+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

@@ -0,0 +1,51 @@
+---
+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

@@ -0,0 +1,31 @@
+---
+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/ci.yml

@@ -14,7 +14,7 @@ permissions:
   contents: read
 
 jobs:
-  build:
+  setup:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -24,21 +24,55 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: "npm"
+          cache: 'npm'
+
+      - name: Install Dependencies
+        id: install
+        run: npm ci
+        timeout-minutes: 2
 
       - 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-
+          path: node_modules
+          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
 
-      - name: Install Dependencies
-        run: npm ci
-        timeout-minutes: 2
+  format-check:
+    needs: setup
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Restore node_modules
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
+
+      - name: Format Check
+        run: npm run format-check
+        env:
+          FORCE_COLOR: 1
+
+  test:
+    needs: setup
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Restore node_modules
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
 
       - name: Run Tests
         run: |
@@ -47,13 +81,13 @@ jobs:
           NODE_ENV: test
           CI: true
           FORCE_COLOR: 1
-        timeout-minutes: 15
+        timeout-minutes: 10
 
       - name: Upload Test Results
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: test-results-node
+          name: test-results
           path: |
             test-results
             coverage

.github/workflows/release.yml

@@ -3,6 +3,9 @@ on:
   push:
     branches:
       - main
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
 jobs:
   release:
     runs-on: ubuntu-latest
@@ -14,7 +17,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: "npm"
+          cache: 'npm'
 
       - name: Cache node_modules
         uses: actions/cache@v4

.gitignore

@@ -9,6 +9,9 @@ jspm_packages/
 .env.test.local
 .env.production.local
 
+# Cursor configuration -- might have ENV variables. Included by default
+# .cursor/mcp.json
+
 # Logs
 logs
 *.log
@@ -16,6 +19,8 @@ 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

.prettierignore

@@ -0,0 +1,7 @@
+# Ignore artifacts:
+build
+coverage
+.changeset
+tasks
+package-lock.json
+tests/fixture/*.json

.prettierrc

@@ -0,0 +1,11 @@
+{
+	"printWidth": 80,
+	"tabWidth": 2,
+	"useTabs": true,
+	"semi": true,
+	"singleQuote": true,
+	"trailingComma": "none",
+	"bracketSpacing": true,
+	"arrowParens": "always",
+	"endOfLine": "lf"
+}

.taskmasterconfig

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

.vscode/extensions.json

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

CHANGELOG.md

@@ -1,5 +1,170 @@
 # task-master-ai
 
+## 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

LICENSE.md

@@ -1,90 +0,0 @@
-# Dual License
-
-This project is licensed under two separate licenses:
-
-1. [Business Source License 1.1](#business-source-license-11) (BSL 1.1) for commercial use of Task Master itself
-2. [Apache License 2.0](#apache-license-20) for all other uses
-
-## Business Source License 1.1
-
-Terms: https://mariadb.com/bsl11/
-
-Licensed Work: Task Master AI
-Additional Use Grant: You may use Task Master AI to create and commercialize your own projects and products.
-
-Change Date: 2025-03-30
-Change License: None
-
-The Licensed Work is subject to the Business Source License 1.1. If you are interested in using the Licensed Work in a way that competes directly with Task Master, please contact the licensors.
-
-### Licensor
-
-- Eyal Toledano (GitHub: @eyaltoledano)
-- Ralph (GitHub: @Crunchyman-ralph)
-
-### Commercial Use Restrictions
-
-This license explicitly restricts certain commercial uses of Task Master AI to the Licensors listed above. Restricted commercial uses include:
-
-1. Creating commercial products or services that directly compete with Task Master AI
-2. Selling Task Master AI itself as a service
-3. Offering Task Master AI's functionality as a commercial managed service
-4. Reselling or redistributing Task Master AI for a fee
-
-### Explicitly Permitted Uses
-
-The following uses are explicitly allowed under this license:
-
-1. Using Task Master AI to create and commercialize your own projects
-2. Using Task Master AI in commercial environments for internal development
-3. Building and selling products or services that were created using Task Master AI
-4. Using Task Master AI for commercial development as long as you're not selling Task Master AI itself
-
-### Additional Terms
-
-1. The right to commercialize Task Master AI itself is exclusively reserved for the Licensors
-2. No party may create commercial products that directly compete with Task Master AI without explicit written permission
-3. Forks of this repository are subject to the same restrictions regarding direct competition
-4. Contributors agree that their contributions will be subject to this same dual licensing structure
-
-## Apache License 2.0
-
-For all uses other than those restricted above. See [APACHE-LICENSE](./APACHE-LICENSE) for the full license text.
-
-### Permitted Use Definition
-
-You may use Task Master AI for any purpose, including commercial purposes, as long as you are not:
-
-1. Creating a direct competitor to Task Master AI
-2. Selling Task Master AI itself as a service
-3. Redistributing Task Master AI for a fee
-
-### Requirements for Use
-
-1. You must include appropriate copyright notices
-2. You must state significant changes made to the software
-3. You must preserve all license notices
-
-## Questions and Commercial Licensing
-
-For questions about licensing or to inquire about commercial use that may compete with Task Master, please contact:
-
-- Eyal Toledano (GitHub: @eyaltoledano)
-- Ralph (GitHub: @Crunchyman-ralph)
-
-## Examples
-
-### ✅ Allowed Uses
-
-- Using Task Master to create a commercial SaaS product
-- Using Task Master in your company for development
-- Creating and selling products that were built using Task Master
-- Using Task Master to generate code for commercial projects
-- Offering consulting services where you use Task Master
-
-### ❌ Restricted Uses
-
-- Creating a competing AI task management tool
-- Selling access to Task Master as a service
-- Creating a hosted version of Task Master
-- Reselling Task Master's functionality

README-task-master.md

@@ -13,25 +13,22 @@ A task management system for AI-driven development with Claude, designed to work
 
 ## Configuration
 
-The script can be configured through environment variables in a `.env` file at the root of the project:
+Taskmaster uses two primary configuration methods:
 
-### Required Configuration
+1.  **`.taskmasterconfig` File (Project Root)**
 
-- `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude
+    - 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.
 
-### Optional Configuration
+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.
 
-- `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
+**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.
 
 ## Installation
 
@@ -50,14 +47,24 @@ 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.
 
 ### Important Notes
 
-1. This package uses ES modules. Your package.json should include `"type": "module"`.
+1. **ES Modules Configuration:**
+
+   - This project uses ES Modules (ESM) instead of CommonJS.
+   - This is set via `"type": "module"` in your package.json.
+   - Use `import/export` syntax instead of `require()`.
+   - Files should use `.js` or `.mjs` extensions.
+   - To use a CommonJS module, either:
+     - Rename it with `.cjs` extension
+     - Use `await import()` for dynamic imports
+   - If you need CommonJS throughout your project, remove `"type": "module"` from package.json, but Task Master scripts expect ESM.
+
 2. The Anthropic SDK version should be 0.39.0 or higher.
 
 ## Quick Start with Global Commands
@@ -136,7 +143,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 --package task-master-ai task-master-mcp"
+   - Command: "npx -y task-master-ai"
 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,62 +1,68 @@
-# Task Master
+# 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)
-[![License: MIT with Commons Clause](https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg)](LICENSE)
-[![npm version](https://badge.fury.io/js/task-master-ai.svg)](https://badge.fury.io/js/task-master-ai)
+[![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)
 
-### by [@eyaltoledano](https://x.com/eyaltoledano)
+### By [@eyaltoledano](https://x.com/eyaltoledano) & [@RalphEcom](https://x.com/RalphEcom)
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/eyaltoledano?style=flat)](https://x.com/eyaltoledano)
+[![Twitter Follow](https://img.shields.io/twitter/follow/RalphEcom?style=flat)](https://x.com/RalphEcom)
 
 A task management system for AI-driven development with Claude, designed to work seamlessly with Cursor AI.
 
-## Licensing
-
-Task Master is licensed under the MIT License with Commons Clause. This means you can:
-
-✅ **Allowed**:
-
-- Use Task Master for any purpose (personal, commercial, academic)
-- Modify the code
-- Distribute copies
-- Create and sell products built using Task Master
-
-❌ **Not Allowed**:
-
-- Sell Task Master itself
-- Offer Task Master as a hosted service
-- Create competing products based on Task Master
-
-See the [LICENSE](LICENSE) file for the complete license text.
-
 ## Requirements
 
-- Node.js 14.0.0 or higher
 - Anthropic API key (Claude API)
-- Anthropic SDK version 0.39.0 or higher
 - OpenAI SDK (for Perplexity API integration, optional)
 
-## Configuration
+## Quick Start
 
-The script can be configured through environment variables in a `.env` file at the root of the project:
+### Option 1 | MCP (Recommended):
 
-### Required Configuration
+MCP (Model Control Protocol) provides the easiest way to get started with Task Master directly in your editor.
 
-- `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude
+1. **Add the MCP config to your editor** (Cursor recommended, but it works with other text editors):
 
-### Optional Configuration
+```json
+{
+	"mcpServers": {
+		"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"
+			}
+		}
+	}
+}
+```
 
-- `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
+2. **Enable the MCP** in your editor
 
-## Installation
+3. **Prompt the AI** to initialize Task Master:
+
+```
+Can you please initialize taskmaster-ai into my project?
+```
+
+4. **Use common commands** directly through your AI assistant:
+
+```txt
+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?
+```
+
+### Option 2: Using Command Line
+
+#### Installation
 
 ```bash
 # Install globally
@@ -66,26 +72,19 @@ npm install -g task-master-ai
 npm install task-master-ai
 ```
 
-### Initialize a new project
+#### Initialize a new project
 
 ```bash
 # If installed globally
 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.
 
-### Important Notes
-
-1. This package uses ES modules. Your package.json should include `"type": "module"`.
-2. The Anthropic SDK version should be 0.39.0 or higher.
-
-## Quick Start with Global Commands
-
-After installing the package globally, you can use these CLI commands from any directory:
+#### Common Commands
 
 ```bash
 # Initialize a new project
@@ -104,6 +103,16 @@ task-master next
 task-master generate
 ```
 
+## Documentation
+
+For more detailed information, check out the documentation in the `docs` directory:
+
+- [Configuration Guide](docs/configuration.md) - Set up environment variables and customize Task Master
+- [Tutorial](docs/tutorial.md) - Step-by-step guide to getting started with Task Master
+- [Command Reference](docs/command-reference.md) - Complete list of all available commands
+- [Task Structure](docs/task-structure.md) - Understanding the task format and features
+- [Example Interactions](docs/examples.md) - Common Cursor AI interaction examples
+
 ## Troubleshooting
 
 ### If `task-master init` doesn't respond:
@@ -122,562 +131,31 @@ cd claude-task-master
 node scripts/init.js
 ```
 
-## Task Structure
+## Contributors
 
-Tasks in tasks.json have the following structure:
+<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>
 
-- `id`: Unique identifier for the task (Example: `1`)
-- `title`: Brief, descriptive title of the task (Example: `"Initialize Repo"`)
-- `description`: Concise description of what the task involves (Example: `"Create a new repository, set up initial structure."`)
-- `status`: Current state of the task (Example: `"pending"`, `"done"`, `"deferred"`)
-- `dependencies`: IDs of tasks that must be completed before this task (Example: `[1, 2]`)
-  - Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending)
-  - This helps quickly identify which prerequisite tasks are blocking work
-- `priority`: Importance level of the task (Example: `"high"`, `"medium"`, `"low"`)
-- `details`: In-depth implementation instructions (Example: `"Use GitHub client ID/secret, handle callback, set session token."`)
-- `testStrategy`: Verification approach (Example: `"Deploy and call endpoint to confirm 'Hello World' response."`)
-- `subtasks`: List of smaller, more specific tasks that make up the main task (Example: `[{"id": 1, "title": "Configure OAuth", ...}]`)
+## Star History
 
-## Integrating with Cursor AI
+[![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)
 
-Claude Task Master is designed to work seamlessly with [Cursor AI](https://www.cursor.so/), providing a structured workflow for AI-driven development.
+## Licensing
 
-### Setup with Cursor
+Task Master is licensed under the MIT License with Commons Clause. This means you can:
 
-1. After initializing your project, open it in Cursor
-2. The `.cursor/rules/dev_workflow.mdc` file is automatically loaded by Cursor, providing the AI with knowledge about the task management system
-3. Place your PRD document in the `scripts/` directory (e.g., `scripts/prd.txt`)
-4. Open Cursor's AI chat and switch to Agent mode
+✅ **Allowed**:
 
-### Setting up MCP in Cursor
+- Use Task Master for any purpose (personal, commercial, academic)
+- Modify the code
+- Distribute copies
+- Create and sell products built using Task Master
 
-To enable enhanced task management capabilities directly within Cursor using the Model Control Protocol (MCP):
+❌ **Not Allowed**:
 
-1. Go to Cursor settings
-2. Navigate to the MCP section
-3. Click on "Add New MCP Server"
-4. Configure with the following details:
-   - Name: "Task Master"
-   - Type: "Command"
-   - Command: "npx -y --package task-master-ai task-master-mcp"
-5. Save the settings
+- Sell Task Master itself
+- Offer Task Master as a hosted service
+- Create competing products based on Task Master
 
-Once configured, you can interact with Task Master's task management commands directly through Cursor's interface, providing a more integrated experience.
-
-### Initial Task Generation
-
-In Cursor's AI chat, instruct the agent to generate tasks from your PRD:
-
-```
-Please use the task-master parse-prd command to generate tasks from my PRD. The PRD is located at scripts/prd.txt.
-```
-
-The agent will execute:
-
-```bash
-task-master parse-prd scripts/prd.txt
-```
-
-This will:
-
-- Parse your PRD document
-- Generate a structured `tasks.json` file with tasks, dependencies, priorities, and test strategies
-- The agent will understand this process due to the Cursor rules
-
-### Generate Individual Task Files
-
-Next, ask the agent to generate individual task files:
-
-```
-Please generate individual task files from tasks.json
-```
-
-The agent will execute:
-
-```bash
-task-master generate
-```
-
-This creates individual task files in the `tasks/` directory (e.g., `task_001.txt`, `task_002.txt`), making it easier to reference specific tasks.
-
-## AI-Driven Development Workflow
-
-The Cursor agent is pre-configured (via the rules file) to follow this workflow:
-
-### 1. Task Discovery and Selection
-
-Ask the agent to list available tasks:
-
-```
-What tasks are available to work on next?
-```
-
-The agent will:
-
-- Run `task-master list` to see all tasks
-- Run `task-master next` to determine the next task to work on
-- Analyze dependencies to determine which tasks are ready to be worked on
-- Prioritize tasks based on priority level and ID order
-- Suggest the next task(s) to implement
-
-### 2. Task Implementation
-
-When implementing a task, the agent will:
-
-- Reference the task's details section for implementation specifics
-- Consider dependencies on previous tasks
-- Follow the project's coding standards
-- Create appropriate tests based on the task's testStrategy
-
-You can ask:
-
-```
-Let's implement task 3. What does it involve?
-```
-
-### 3. Task Verification
-
-Before marking a task as complete, verify it according to:
-
-- The task's specified testStrategy
-- Any automated tests in the codebase
-- Manual verification if required
-
-### 4. Task Completion
-
-When a task is completed, tell the agent:
-
-```
-Task 3 is now complete. Please update its status.
-```
-
-The agent will execute:
-
-```bash
-task-master set-status --id=3 --status=done
-```
-
-### 5. Handling Implementation Drift
-
-If during implementation, you discover that:
-
-- The current approach differs significantly from what was planned
-- Future tasks need to be modified due to current implementation choices
-- New dependencies or requirements have emerged
-
-Tell the agent:
-
-```
-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 Express instead of Fastify."
-```
-
-This will rewrite or re-scope subsequent tasks in tasks.json while preserving completed work.
-
-### 6. Breaking Down Complex Tasks
-
-For complex tasks that need more granularity:
-
-```
-Task 5 seems complex. Can you break it down into subtasks?
-```
-
-The agent will execute:
-
-```bash
-task-master expand --id=5 --num=3
-```
-
-You can provide additional context:
-
-```
-Please break down task 5 with a focus on security considerations.
-```
-
-The agent will execute:
-
-```bash
-task-master expand --id=5 --prompt="Focus on security aspects"
-```
-
-You can also expand all pending tasks:
-
-```
-Please break down all pending tasks into subtasks.
-```
-
-The agent will execute:
-
-```bash
-task-master expand --all
-```
-
-For research-backed subtask generation using Perplexity AI:
-
-```
-Please break down task 5 using research-backed generation.
-```
-
-The agent will execute:
-
-```bash
-task-master expand --id=5 --research
-```
-
-## Command Reference
-
-Here's a comprehensive reference of all available commands:
-
-### Parse PRD
-
-```bash
-# Parse a PRD file and generate tasks
-task-master parse-prd <prd-file.txt>
-
-# Limit the number of tasks generated
-task-master parse-prd <prd-file.txt> --num-tasks=10
-```
-
-### List Tasks
-
-```bash
-# List all tasks
-task-master list
-
-# List tasks with a specific status
-task-master list --status=<status>
-
-# List tasks with subtasks
-task-master list --with-subtasks
-
-# List tasks with a specific status and include subtasks
-task-master list --status=<status> --with-subtasks
-```
-
-### Show Next Task
-
-```bash
-# Show the next task to work on based on dependencies and status
-task-master next
-```
-
-### Show Specific Task
-
-```bash
-# Show details of a specific task
-task-master show <id>
-# or
-task-master show --id=<id>
-
-# View a specific subtask (e.g., subtask 2 of task 1)
-task-master show 1.2
-```
-
-### Update Tasks
-
-```bash
-# Update tasks from a specific ID and provide context
-task-master update --from=<id> --prompt="<prompt>"
-```
-
-### Update a Specific Task
-
-```bash
-# Update a single task by ID with new information
-task-master update-task --id=<id> --prompt="<prompt>"
-
-# Use research-backed updates with Perplexity AI
-task-master update-task --id=<id> --prompt="<prompt>" --research
-```
-
-### Update a Subtask
-
-```bash
-# Append additional information to a specific subtask
-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 with Perplexity AI
-task-master update-subtask --id=<parentId.subtaskId> --prompt="<prompt>" --research
-```
-
-Unlike the `update-task` command which replaces task information, the `update-subtask` command _appends_ new information to the existing subtask details, marking it with a timestamp. This is useful for iteratively enhancing subtasks while preserving the original content.
-
-### Generate Task Files
-
-```bash
-# Generate individual task files from tasks.json
-task-master generate
-```
-
-### Set Task Status
-
-```bash
-# Set status of a single task
-task-master set-status --id=<id> --status=<status>
-
-# Set status for multiple tasks
-task-master set-status --id=1,2,3 --status=<status>
-
-# Set status for subtasks
-task-master set-status --id=1.1,1.2 --status=<status>
-```
-
-When marking a task as "done", all of its subtasks will automatically be marked as "done" as well.
-
-### Expand Tasks
-
-```bash
-# Expand a specific task with subtasks
-task-master expand --id=<id> --num=<number>
-
-# Expand with additional context
-task-master expand --id=<id> --prompt="<context>"
-
-# Expand all pending tasks
-task-master expand --all
-
-# Force regeneration of subtasks for tasks that already have them
-task-master expand --all --force
-
-# Research-backed subtask generation for a specific task
-task-master expand --id=<id> --research
-
-# Research-backed generation for all tasks
-task-master expand --all --research
-```
-
-### Clear Subtasks
-
-```bash
-# Clear subtasks from a specific task
-task-master clear-subtasks --id=<id>
-
-# Clear subtasks from multiple tasks
-task-master clear-subtasks --id=1,2,3
-
-# Clear subtasks from all tasks
-task-master clear-subtasks --all
-```
-
-### Analyze Task Complexity
-
-```bash
-# Analyze complexity of all tasks
-task-master analyze-complexity
-
-# Save report to a custom location
-task-master analyze-complexity --output=my-report.json
-
-# Use a specific LLM model
-task-master analyze-complexity --model=claude-3-opus-20240229
-
-# Set a custom complexity threshold (1-10)
-task-master analyze-complexity --threshold=6
-
-# Use an alternative tasks file
-task-master analyze-complexity --file=custom-tasks.json
-
-# Use Perplexity AI for research-backed complexity analysis
-task-master analyze-complexity --research
-```
-
-### View Complexity Report
-
-```bash
-# Display the task complexity analysis report
-task-master complexity-report
-
-# View a report at a custom location
-task-master complexity-report --file=my-report.json
-```
-
-### Managing Task Dependencies
-
-```bash
-# Add a dependency to a task
-task-master add-dependency --id=<id> --depends-on=<id>
-
-# Remove a dependency from a task
-task-master remove-dependency --id=<id> --depends-on=<id>
-
-# Validate dependencies without fixing them
-task-master validate-dependencies
-
-# Find and fix invalid dependencies automatically
-task-master fix-dependencies
-```
-
-### Add a New Task
-
-```bash
-# Add a new task using AI
-task-master add-task --prompt="Description of the new task"
-
-# Add a task with dependencies
-task-master add-task --prompt="Description" --dependencies=1,2,3
-
-# Add a task with priority
-task-master add-task --prompt="Description" --priority=high
-```
-
-## Feature Details
-
-### Analyzing Task Complexity
-
-The `analyze-complexity` command:
-
-- Analyzes each task using AI to assess its complexity on a scale of 1-10
-- Recommends optimal number of subtasks based on configured DEFAULT_SUBTASKS
-- Generates tailored prompts for expanding each task
-- Creates a comprehensive JSON report with ready-to-use commands
-- Saves the report to scripts/task-complexity-report.json by default
-
-The generated report contains:
-
-- Complexity analysis for each task (scored 1-10)
-- Recommended number of subtasks based on complexity
-- AI-generated expansion prompts customized for each task
-- Ready-to-run expansion commands directly within each task analysis
-
-### Viewing Complexity Report
-
-The `complexity-report` command:
-
-- Displays a formatted, easy-to-read version of the complexity analysis report
-- Shows tasks organized by complexity score (highest to lowest)
-- Provides complexity distribution statistics (low, medium, high)
-- Highlights tasks recommended for expansion based on threshold score
-- Includes ready-to-use expansion commands for each complex task
-- If no report exists, offers to generate one on the spot
-
-### Smart Task Expansion
-
-The `expand` command automatically checks for and uses the complexity report:
-
-When a complexity report exists:
-
-- Tasks are automatically expanded using the recommended subtask count and prompts
-- When expanding all tasks, they're processed in order of complexity (highest first)
-- Research-backed generation is preserved from the complexity analysis
-- You can still override recommendations with explicit command-line options
-
-Example workflow:
-
-```bash
-# Generate the complexity analysis report with research capabilities
-task-master analyze-complexity --research
-
-# Review the report in a readable format
-task-master complexity-report
-
-# Expand tasks using the optimized recommendations
-task-master expand --id=8
-# or expand all tasks
-task-master expand --all
-```
-
-### Finding the Next Task
-
-The `next` command:
-
-- Identifies tasks that are pending/in-progress and have all dependencies satisfied
-- Prioritizes tasks by priority level, dependency count, and task ID
-- Displays comprehensive information about the selected task:
-  - Basic task details (ID, title, priority, dependencies)
-  - Implementation details
-  - Subtasks (if they exist)
-- Provides contextual suggested actions:
-  - Command to mark the task as in-progress
-  - Command to mark the task as done
-  - Commands for working with subtasks
-
-### Viewing Specific Task Details
-
-The `show` command:
-
-- Displays comprehensive details about a specific task or subtask
-- Shows task status, priority, dependencies, and detailed implementation notes
-- For parent tasks, displays all subtasks and their status
-- For subtasks, shows parent task relationship
-- Provides contextual action suggestions based on the task's state
-- Works with both regular tasks and subtasks (using the format taskId.subtaskId)
-
-## Best Practices for AI-Driven Development
-
-1. **Start with a detailed PRD**: The more detailed your PRD, the better the generated tasks will be.
-
-2. **Review generated tasks**: After parsing the PRD, review the tasks to ensure they make sense and have appropriate dependencies.
-
-3. **Analyze task complexity**: Use the complexity analysis feature to identify which tasks should be broken down further.
-
-4. **Follow the dependency chain**: Always respect task dependencies - the Cursor agent will help with this.
-
-5. **Update as you go**: If your implementation diverges from the plan, use the update command to keep future tasks aligned with your current approach.
-
-6. **Break down complex tasks**: Use the expand command to break down complex tasks into manageable subtasks.
-
-7. **Regenerate task files**: After any updates to tasks.json, regenerate the task files to keep them in sync.
-
-8. **Communicate context to the agent**: When asking the Cursor agent to help with a task, provide context about what you're trying to achieve.
-
-9. **Validate dependencies**: Periodically run the validate-dependencies command to check for invalid or circular dependencies.
-
-## Example Cursor AI Interactions
-
-### Starting a new project
-
-```
-I've just initialized a new project with Claude Task Master. I have a PRD at scripts/prd.txt.
-Can you help me parse it and set up the initial tasks?
-```
-
-### Working on tasks
-
-```
-What's the next task I should work on? Please consider dependencies and priorities.
-```
-
-### Implementing a specific task
-
-```
-I'd like to implement task 4. Can you help me understand what needs to be done and how to approach it?
-```
-
-### Managing subtasks
-
-```
-I need to regenerate the subtasks for task 3 with a different approach. Can you help me clear and regenerate them?
-```
-
-### Handling changes
-
-```
-We've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks to reflect this change?
-```
-
-### Completing work
-
-```
-I've finished implementing the authentication system described in task 2. All tests are passing.
-Please mark it as complete and tell me what I should work on next.
-```
-
-### Analyzing complexity
-
-```
-Can you analyze the complexity of our tasks to help me understand which ones need to be broken down further?
-```
-
-### Viewing complexity report
-
-```
-Can you show me the complexity report in a more readable format?
-```
+See the [LICENSE](LICENSE) file for the complete license text and [licensing details](docs/licensing.md) for more information.

assets/.taskmasterconfig

@@ -0,0 +1,31 @@
+{
+	"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": 120000,
+			"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/env.example

@@ -1,14 +1,8 @@
-# Required
-ANTHROPIC_API_KEY=your-api-key-here  # Format: sk-ant-api03-...
-PERPLEXITY_API_KEY=pplx-abcde # For research (recommended but optional)
-
-# Optional - defaults shown
-MODEL=claude-3-7-sonnet-20250219  # Recommended models: claude-3-7-sonnet-20250219, claude-3-opus-20240229
-PERPLEXITY_MODEL=sonar-pro        # Make sure you have access to sonar-pro otherwise you can use sonar regular.
-MAX_TOKENS=4000                   # Maximum tokens for model responses
-TEMPERATURE=0.7                   # Temperature for model responses (0.0-1.0)
-DEBUG=false                       # Enable debug logging (true/false)
-LOG_LEVEL=info                    # Log level (debug, info, warn, error)
-DEFAULT_SUBTASKS=3                # 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
+# 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).

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

@@ -0,0 +1,93 @@
+**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

@@ -0,0 +1,89 @@
+**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

@@ -0,0 +1,181 @@
+**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

@@ -0,0 +1,61 @@
+**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

@@ -0,0 +1,68 @@
+**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

@@ -0,0 +1,61 @@
+**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

@@ -0,0 +1,63 @@
+{
+  "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 mdode, 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,29 +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
+## Configuration (Updated)
 
-The script can be configured through environment variables in a `.env` file at the root of the project:
+Task Master configuration is now managed through two primary methods:
 
-### Required Configuration
-- `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude
+1.  **`.taskmasterconfig` File (Project Root - Primary)**
 
-### Optional Configuration
-- `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
+    - 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.
+
+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.
+
+**Important:** Settings like `MODEL`, `MAX_TOKENS`, `TEMPERATURE`, `LOG_LEVEL`, etc., are **no longer set via `.env`**. Use `task-master models --setup` instead.
 
 ## How It Works
 
 1. **`tasks.json`**:
+
    - A JSON file at the project root containing an array of tasks (each with `id`, `title`, `description`, `status`, etc.).
    - The `meta` field can store additional info like the project's name, version, or reference to the PRD.
    - Tasks can have `subtasks` for more detailed implementation steps.
@@ -111,6 +109,7 @@ task-master update --file=custom-tasks.json --from=5 --prompt="Change database f
 ```
 
 Notes:
+
 - The `--prompt` parameter is required and should explain the changes or new context
 - Only tasks that aren't marked as 'done' will be updated
 - Tasks with ID >= the specified --from value will be updated
@@ -134,6 +133,7 @@ task-master set-status --id=1,2,3 --status=done
 ```
 
 Notes:
+
 - When marking a parent task as "done", all of its subtasks will automatically be marked as "done" as well
 - Common status values are 'done', 'pending', and 'deferred', but any string is accepted
 - You can specify multiple task IDs by separating them with commas
@@ -183,29 +183,25 @@ task-master clear-subtasks --all
 ```
 
 Notes:
+
 - After clearing subtasks, task files are automatically regenerated
 - This is useful when you want to regenerate subtasks with a different approach
 - Can be combined with the `expand` command to immediately generate new subtasks
 - Works with both parent tasks and individual subtasks
 
-## AI Integration
+## AI Integration (Updated)
 
-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
+- 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.
 
 ## Logging
 
 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)
 - `warn`: Warning messages that don't prevent execution
@@ -228,17 +224,20 @@ task-master remove-dependency --id=<id> --depends-on=<id>
 These commands:
 
 1. **Allow precise dependency management**:
+
    - Add dependencies between tasks with automatic validation
    - Remove dependencies when they're no longer needed
    - Update task files automatically after changes
 
 2. **Include validation checks**:
+
    - Prevent circular dependencies (a task depending on itself)
    - Prevent duplicate dependencies
    - Verify that both tasks exist before adding/removing dependencies
    - Check if dependencies exist before attempting to remove them
 
 3. **Provide clear feedback**:
+
    - Success messages confirm when dependencies are added/removed
    - Error messages explain why operations failed (if applicable)
 
@@ -263,6 +262,7 @@ task-master validate-dependencies --file=custom-tasks.json
 ```
 
 This command:
+
 - Scans all tasks and subtasks for non-existent dependencies
 - Identifies potential self-dependencies (tasks referencing themselves)
 - Reports all found issues without modifying files
@@ -284,6 +284,7 @@ task-master fix-dependencies --file=custom-tasks.json
 ```
 
 This command:
+
 1. **Validates all dependencies** across tasks and subtasks
 2. **Automatically removes**:
    - References to non-existent tasks and subtasks
@@ -321,6 +322,7 @@ task-master analyze-complexity --research
 ```
 
 Notes:
+
 - The command uses Claude to analyze each task's complexity (or Perplexity with --research flag)
 - Tasks are scored on a scale of 1-10
 - Each task receives a recommended number of subtasks based on DEFAULT_SUBTASKS configuration
@@ -345,12 +347,14 @@ task-master expand --id=8 --num=5 --prompt="Custom prompt"
 ```
 
 When a complexity report exists:
+
 - The `expand` command will use the recommended subtask count from the report (unless overridden)
 - It will use the tailored expansion prompt from the report (unless a custom prompt is provided)
 - When using `--all`, tasks are sorted by complexity score (highest first)
 - The `--research` flag is preserved from the complexity analysis to expansion
 
 The output report structure is:
+
 ```json
 {
 	"meta": {
@@ -369,7 +373,7 @@ The output report structure is:
 			"expansionPrompt": "Create subtasks that handle detecting...",
 			"reasoning": "This task requires sophisticated logic...",
 			"expansionCommand": "task-master expand --id=8 --num=6 --prompt=\"Create subtasks...\" --research"
-    },
+		}
 		// More tasks sorted by complexity score (highest first)
 	]
 }

bin/task-master-init.js

@@ -1,30 +0,0 @@
-#!/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

@@ -49,7 +49,13 @@ function runDevScript(args) {
 		console.error('\nDEBUG - CLI Wrapper Analysis:');
 		console.error('- Original command: ' + process.argv.join(' '));
 		console.error('- Transformed args: ' + args.join(' '));
-    console.error('- dev.js will receive: node ' + devScriptPath + ' ' + args.join(' ') + '\n');
+		console.error(
+			'- dev.js will receive: node ' +
+				devScriptPath +
+				' ' +
+				args.join(' ') +
+				'\n'
+		);
 	}
 
 	// For testing: If TEST_MODE is set, just print args and exit
@@ -86,11 +92,13 @@ function createDevScriptAction(commandName) {
 		// If camelCase flags were found, show error and exit
 		if (camelCaseFlags.length > 0) {
 			console.error('\nError: Please use kebab-case for CLI flags:');
-      camelCaseFlags.forEach(flag => {
+			camelCaseFlags.forEach((flag) => {
 				console.error(`  Instead of: --${flag.original}`);
 				console.error(`  Use:        --${flag.kebabCase}`);
 			});
-      console.error('\nExample: task-master parse-prd --num-tasks=5 instead of --numTasks=5\n');
+			console.error(
+				'\nExample: task-master parse-prd --num-tasks=5 instead of --numTasks=5\n'
+			);
 			process.exit(1);
 		}
 
@@ -113,9 +121,11 @@ function createDevScriptAction(commandName) {
 					// It's a flag - pass through as is
 					commandArgs.push(arg);
 					// Skip the next arg if this is a flag with a value (not --flag=value format)
-          if (!arg.includes('=') && 
+					if (
+						!arg.includes('=') &&
 						i + 1 < process.argv.length &&
-              !process.argv[i+1].startsWith('--')) {
+						!process.argv[i + 1].startsWith('--')
+					) {
 						commandArgs.push(process.argv[++i]);
 					}
 				} else if (!positionals.has(arg)) {
@@ -143,7 +153,9 @@ function createDevScriptAction(commandName) {
 				userOptions.add(kebabName);
 
 				// Add the camelCase version as well
-        const camelName = kebabName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+				const camelName = kebabName.replace(/-([a-z])/g, (_, letter) =>
+					letter.toUpperCase()
+				);
 				userOptions.add(camelName);
 			}
 		}
@@ -167,7 +179,10 @@ function createDevScriptAction(commandName) {
 			}
 
 			// Skip built-in Commander properties and options the user provided
-      if (['parent', 'commands', 'options', 'rawArgs'].includes(key) || userOptions.has(key)) {
+			if (
+				['parent', 'commands', 'options', 'rawArgs'].includes(key) ||
+				userOptions.has(key)
+			) {
 				return;
 			}
 
@@ -210,39 +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();
@@ -263,8 +286,8 @@ program.on('--help', () => {
 	displayHelp();
 });
 
-// Add special case commands
-registerInitCommand(program);
+// // Add special case commands
+// registerInitCommand(program);
 
 program
 	.command('dev')
@@ -279,24 +302,18 @@ const tempProgram = new Command();
 registerCommands(tempProgram);
 
 // For each command in the temp instance, add a modified version to our actual program
-tempProgram.commands.forEach(cmd => {
-  if (['init', 'dev'].includes(cmd.name())) {
+tempProgram.commands.forEach((cmd) => {
+	if (['dev'].includes(cmd.name())) {
 		// Skip commands we've already defined specially
 		return;
 	}
 
 	// Create a new command with the same name and description
-  const newCmd = program
-    .command(cmd.name())
-    .description(cmd.description());
+	const newCmd = program.command(cmd.name()).description(cmd.description());
 
 	// Copy all options
-  cmd.options.forEach(opt => {
-    newCmd.option(
-      opt.flags,
-      opt.description,
-      opt.defaultValue
-    );
+	cmd.options.forEach((opt) => {
+		newCmd.option(opt.flags, opt.description, opt.defaultValue);
 	});
 
 	// Set the action to proxy to dev.js
@@ -311,14 +328,21 @@ process.on('uncaughtException', (err) => {
 	// Check if this is a commander.js unknown option error
 	if (err.code === 'commander.unknownOption') {
 		const option = err.message.match(/'([^']+)'/)?.[1];
-    const commandArg = process.argv.find(arg => !arg.startsWith('-') && 
+		const commandArg = process.argv.find(
+			(arg) =>
+				!arg.startsWith('-') &&
 				arg !== 'task-master' &&
 				!arg.includes('/') &&
-                                            arg !== 'node');
+				arg !== 'node'
+		);
 		const command = commandArg || 'unknown';
 
 		console.error(chalk.red(`Error: Unknown option '${option}'`));
-    console.error(chalk.yellow(`Run 'task-master ${command} --help' to see available options for this command`));
+		console.error(
+			chalk.yellow(
+				`Run 'task-master ${command} --help' to see available options for this command`
+			)
+		);
 		process.exit(1);
 	}
 
@@ -327,7 +351,9 @@ process.on('uncaughtException', (err) => {
 		const command = err.message.match(/'([^']+)'/)?.[1];
 
 		console.error(chalk.red(`Error: Unknown command '${command}'`));
-    console.error(chalk.yellow(`Run 'task-master --help' to see available commands`));
+		console.error(
+			chalk.yellow(`Run 'task-master --help' to see available commands`)
+		);
 		process.exit(1);
 	}
 

context/MCP_INTEGRATION.md

@@ -186,22 +186,22 @@ const commandMap = {
 
 ```javascript
 // In mcp-server/src/tools/newFeature.js
-import { z } from "zod";
+import { z } from 'zod';
 import {
 	executeTaskMasterCommand,
 	createContentResponse,
-  createErrorResponse,
-} from "./utils.js";
+	createErrorResponse
+} from './utils.js';
 
 export function registerNewFeatureTool(server) {
 	server.addTool({
-    name: "newFeature",
-    description: "Run the new feature",
+		name: 'newFeature',
+		description: 'Run the new feature',
 		parameters: z.object({
-      param1: z.string().describe("First parameter"),
-      param2: z.number().optional().describe("Second parameter"),
-      file: z.string().optional().describe("Path to the tasks file"),
-      projectRoot: z.string().describe("Root directory of the project")
+			param1: z.string().describe('First parameter'),
+			param2: z.number().optional().describe('Second parameter'),
+			file: z.string().optional().describe('Path to the tasks file'),
+			projectRoot: z.string().describe('Root directory of the project')
 		}),
 		execute: async (args, { log }) => {
 			try {
@@ -216,7 +216,7 @@ export function registerNewFeatureTool(server) {
 
 				// Execute the command
 				const result = await executeTaskMasterCommand(
-          "new-feature",
+					'new-feature',
 					log,
 					cmdArgs,
 					projectRoot
@@ -231,7 +231,7 @@ export function registerNewFeatureTool(server) {
 				log.error(`Error in new feature: ${error.message}`);
 				return createErrorResponse(`Error in new feature: ${error.message}`);
 			}
-    },
+		}
 	});
 }
 ```
@@ -240,7 +240,7 @@ export function registerNewFeatureTool(server) {
 
 ```javascript
 // In mcp-server/src/tools/index.js
-import { registerNewFeatureTool } from "./newFeature.js";
+import { registerNewFeatureTool } from './newFeature.js';
 
 export function registerTaskMasterTools(server) {
 	// ... existing registrations

docs/README.md

@@ -0,0 +1,22 @@
+# Task Master Documentation
+
+Welcome to the Task Master documentation. Use the links below to navigate to the information you need:
+
+## Getting Started
+
+- [Configuration Guide](configuration.md) - Set up environment variables and customize Task Master
+- [Tutorial](tutorial.md) - Step-by-step guide to getting started with Task Master
+
+## Reference
+
+- [Command Reference](command-reference.md) - Complete list of all available commands
+- [Task Structure](task-structure.md) - Understanding the task format and features
+
+## Examples & Licensing
+
+- [Example Interactions](examples.md) - Common Cursor AI interaction examples
+- [Licensing Information](licensing.md) - Detailed information about the license
+
+## Need More Help?
+
+If you can't find what you're looking for in these docs, please check the [main README](../README.md) or visit our [GitHub repository](https://github.com/eyaltoledano/claude-task-master).

docs/command-reference.md

@@ -0,0 +1,238 @@
+# Task Master Command Reference
+
+Here's a comprehensive reference of all available commands:
+
+## Parse PRD
+
+```bash
+# Parse a PRD file and generate tasks
+task-master parse-prd <prd-file.txt>
+
+# Limit the number of tasks generated
+task-master parse-prd <prd-file.txt> --num-tasks=10
+```
+
+## List Tasks
+
+```bash
+# List all tasks
+task-master list
+
+# List tasks with a specific status
+task-master list --status=<status>
+
+# List tasks with subtasks
+task-master list --with-subtasks
+
+# List tasks with a specific status and include subtasks
+task-master list --status=<status> --with-subtasks
+```
+
+## Show Next Task
+
+```bash
+# Show the next task to work on based on dependencies and status
+task-master next
+```
+
+## Show Specific Task
+
+```bash
+# Show details of a specific task
+task-master show <id>
+# or
+task-master show --id=<id>
+
+# View a specific subtask (e.g., subtask 2 of task 1)
+task-master show 1.2
+```
+
+## Update Tasks
+
+```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
+
+```bash
+# Update a single task by ID with new information
+task-master update-task --id=<id> --prompt="<prompt>"
+
+# Use research-backed updates
+task-master update-task --id=<id> --prompt="<prompt>" --research
+```
+
+## Update a Subtask
+
+```bash
+# Append additional information to a specific subtask
+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
+task-master update-subtask --id=<parentId.subtaskId> --prompt="<prompt>" --research
+```
+
+Unlike the `update-task` command which replaces task information, the `update-subtask` command _appends_ new information to the existing subtask details, marking it with a timestamp. This is useful for iteratively enhancing subtasks while preserving the original content.
+
+## Generate Task Files
+
+```bash
+# Generate individual task files from tasks.json
+task-master generate
+```
+
+## Set Task Status
+
+```bash
+# Set status of a single task
+task-master set-status --id=<id> --status=<status>
+
+# Set status for multiple tasks
+task-master set-status --id=1,2,3 --status=<status>
+
+# Set status for subtasks
+task-master set-status --id=1.1,1.2 --status=<status>
+```
+
+When marking a task as "done", all of its subtasks will automatically be marked as "done" as well.
+
+## Expand Tasks
+
+```bash
+# Expand a specific task with subtasks
+task-master expand --id=<id> --num=<number>
+
+# Expand with additional context
+task-master expand --id=<id> --prompt="<context>"
+
+# Expand all pending tasks
+task-master expand --all
+
+# Force regeneration of subtasks for tasks that already have them
+task-master expand --all --force
+
+# Research-backed subtask generation for a specific task
+task-master expand --id=<id> --research
+
+# Research-backed generation for all tasks
+task-master expand --all --research
+```
+
+## Clear Subtasks
+
+```bash
+# Clear subtasks from a specific task
+task-master clear-subtasks --id=<id>
+
+# Clear subtasks from multiple tasks
+task-master clear-subtasks --id=1,2,3
+
+# Clear subtasks from all tasks
+task-master clear-subtasks --all
+```
+
+## Analyze Task Complexity
+
+```bash
+# Analyze complexity of all tasks
+task-master analyze-complexity
+
+# Save report to a custom location
+task-master analyze-complexity --output=my-report.json
+
+# Use a specific LLM model
+task-master analyze-complexity --model=claude-3-opus-20240229
+
+# Set a custom complexity threshold (1-10)
+task-master analyze-complexity --threshold=6
+
+# Use an alternative tasks file
+task-master analyze-complexity --file=custom-tasks.json
+
+# Use Perplexity AI for research-backed complexity analysis
+task-master analyze-complexity --research
+```
+
+## View Complexity Report
+
+```bash
+# Display the task complexity analysis report
+task-master complexity-report
+
+# View a report at a custom location
+task-master complexity-report --file=my-report.json
+```
+
+## Managing Task Dependencies
+
+```bash
+# Add a dependency to a task
+task-master add-dependency --id=<id> --depends-on=<id>
+
+# Remove a dependency from a task
+task-master remove-dependency --id=<id> --depends-on=<id>
+
+# Validate dependencies without fixing them
+task-master validate-dependencies
+
+# Find and fix invalid dependencies automatically
+task-master fix-dependencies
+```
+
+## Add a New Task
+
+```bash
+# Add a new task using AI (main role)
+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
+
+# Add a task with priority
+task-master add-task --prompt="Description" --priority=high
+```
+
+## Initialize a Project
+
+```bash
+# 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

@@ -0,0 +1,101 @@
+# Configuration
+
+Taskmaster uses two primary methods for configuration:
+
+1.  **`.taskmasterconfig` File (Project Root - Recommended for most settings)**
+
+    - 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
+      		},
+      		"research": {
+      			"provider": "perplexity",
+      			"modelId": "sonar-pro",
+      			"maxTokens": 8700,
+      			"temperature": 0.1
+      		},
+      		"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/"
+      	}
+      }
+      ```
+
+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 (in .taskmasterconfig):**
+      - `AZURE_OPENAI_ENDPOINT`: Required if using Azure OpenAI key.
+      - `OLLAMA_BASE_URL`: Override the default Ollama API URL (Default: `http://localhost:11434/api`).
+
+**Important:** Settings like model ID selections (`main`, `research`, `fallback`), `maxTokens`, `temperature`, `logLevel`, `defaultSubtasks`, `defaultPriority`, and `projectName` are **managed in `.taskmasterconfig`**, not environment variables.
+
+## Example `.env` File (for API Keys)
+
+```
+# 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.
+
+# Optional Endpoint Overrides
+# AZURE_OPENAI_ENDPOINT=https://your-azure-endpoint.openai.azure.com/
+# OLLAMA_BASE_URL=http://custom-ollama-host:11434/api
+```
+
+## 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:
+
+```bash
+node node_modules/claude-task-master/scripts/init.js
+```
+
+Or clone the repository and run:
+
+```bash
+git clone https://github.com/eyaltoledano/claude-task-master.git
+cd claude-task-master
+node scripts/init.js
+```

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

@@ -0,0 +1,94 @@
+# 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

@@ -0,0 +1,83 @@
+# Example Cursor AI Interactions
+
+Here are some common interactions with Cursor AI when using Task Master:
+
+## Starting a new project
+
+```
+I've just initialized a new project with Claude Task Master. I have a PRD at scripts/prd.txt.
+Can you help me parse it and set up the initial tasks?
+```
+
+## Working on tasks
+
+```
+What's the next task I should work on? Please consider dependencies and priorities.
+```
+
+## Implementing a specific task
+
+```
+I'd like to implement task 4. Can you help me understand what needs to be done and how to approach it?
+```
+
+## Managing subtasks
+
+```
+I need to regenerate the subtasks for task 3 with a different approach. Can you help me clear and regenerate them?
+```
+
+## Handling changes
+
+```
+We've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks to reflect this change?
+```
+
+## Completing work
+
+```
+I've finished implementing the authentication system described in task 2. All tests are passing.
+Please mark it as complete and tell me what I should work on next.
+```
+
+## Analyzing complexity
+
+```
+Can you analyze the complexity of our tasks to help me understand which ones need to be broken down further?
+```
+
+## Viewing complexity report
+
+```
+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/licensing.md

@@ -0,0 +1,18 @@
+# Licensing
+
+Task Master is licensed under the MIT License with Commons Clause. This means you can:
+
+## ✅ Allowed:
+
+- Use Task Master for any purpose (personal, commercial, academic)
+- Modify the code
+- Distribute copies
+- Create and sell products built using Task Master
+
+## ❌ Not Allowed:
+
+- Sell Task Master itself
+- Offer Task Master as a hosted service
+- Create competing products based on Task Master
+
+See the [LICENSE](../LICENSE) file for the complete license text.

docs/task-structure.md

@@ -0,0 +1,139 @@
+# Task Structure
+
+Tasks in Task Master follow a specific format designed to provide comprehensive information for both humans and AI assistants.
+
+## Task Fields in tasks.json
+
+Tasks in tasks.json have the following structure:
+
+- `id`: Unique identifier for the task (Example: `1`)
+- `title`: Brief, descriptive title of the task (Example: `"Initialize Repo"`)
+- `description`: Concise description of what the task involves (Example: `"Create a new repository, set up initial structure."`)
+- `status`: Current state of the task (Example: `"pending"`, `"done"`, `"deferred"`)
+- `dependencies`: IDs of tasks that must be completed before this task (Example: `[1, 2]`)
+  - Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending)
+  - This helps quickly identify which prerequisite tasks are blocking work
+- `priority`: Importance level of the task (Example: `"high"`, `"medium"`, `"low"`)
+- `details`: In-depth implementation instructions (Example: `"Use GitHub client ID/secret, handle callback, set session token."`)
+- `testStrategy`: Verification approach (Example: `"Deploy and call endpoint to confirm 'Hello World' response."`)
+- `subtasks`: List of smaller, more specific tasks that make up the main task (Example: `[{"id": 1, "title": "Configure OAuth", ...}]`)
+
+## Task File Format
+
+Individual task files follow this format:
+
+```
+# Task ID: <id>
+# Title: <title>
+# Status: <status>
+# Dependencies: <comma-separated list of dependency IDs>
+# Priority: <priority>
+# Description: <brief description>
+# Details:
+<detailed implementation notes>
+
+# Test Strategy:
+<verification approach>
+```
+
+## Features in Detail
+
+### Analyzing Task Complexity
+
+The `analyze-complexity` command:
+
+- Analyzes each task using AI to assess its complexity on a scale of 1-10
+- Recommends optimal number of subtasks based on configured DEFAULT_SUBTASKS
+- Generates tailored prompts for expanding each task
+- Creates a comprehensive JSON report with ready-to-use commands
+- Saves the report to scripts/task-complexity-report.json by default
+
+The generated report contains:
+
+- Complexity analysis for each task (scored 1-10)
+- Recommended number of subtasks based on complexity
+- AI-generated expansion prompts customized for each task
+- Ready-to-run expansion commands directly within each task analysis
+
+### Viewing Complexity Report
+
+The `complexity-report` command:
+
+- Displays a formatted, easy-to-read version of the complexity analysis report
+- Shows tasks organized by complexity score (highest to lowest)
+- Provides complexity distribution statistics (low, medium, high)
+- Highlights tasks recommended for expansion based on threshold score
+- Includes ready-to-use expansion commands for each complex task
+- If no report exists, offers to generate one on the spot
+
+### Smart Task Expansion
+
+The `expand` command automatically checks for and uses the complexity report:
+
+When a complexity report exists:
+
+- Tasks are automatically expanded using the recommended subtask count and prompts
+- When expanding all tasks, they're processed in order of complexity (highest first)
+- Research-backed generation is preserved from the complexity analysis
+- You can still override recommendations with explicit command-line options
+
+Example workflow:
+
+```bash
+# Generate the complexity analysis report with research capabilities
+task-master analyze-complexity --research
+
+# Review the report in a readable format
+task-master complexity-report
+
+# Expand tasks using the optimized recommendations
+task-master expand --id=8
+# or expand all tasks
+task-master expand --all
+```
+
+### Finding the Next Task
+
+The `next` command:
+
+- Identifies tasks that are pending/in-progress and have all dependencies satisfied
+- Prioritizes tasks by priority level, dependency count, and task ID
+- Displays comprehensive information about the selected task:
+  - Basic task details (ID, title, priority, dependencies)
+  - Implementation details
+  - Subtasks (if they exist)
+- Provides contextual suggested actions:
+  - Command to mark the task as in-progress
+  - Command to mark the task as done
+  - Commands for working with subtasks
+
+### Viewing Specific Task Details
+
+The `show` command:
+
+- Displays comprehensive details about a specific task or subtask
+- Shows task status, priority, dependencies, and detailed implementation notes
+- For parent tasks, displays all subtasks and their status
+- For subtasks, shows parent task relationship
+- Provides contextual action suggestions based on the task's state
+- Works with both regular tasks and subtasks (using the format taskId.subtaskId)
+
+## Best Practices for AI-Driven Development
+
+1. **Start with a detailed PRD**: The more detailed your PRD, the better the generated tasks will be.
+
+2. **Review generated tasks**: After parsing the PRD, review the tasks to ensure they make sense and have appropriate dependencies.
+
+3. **Analyze task complexity**: Use the complexity analysis feature to identify which tasks should be broken down further.
+
+4. **Follow the dependency chain**: Always respect task dependencies - the Cursor agent will help with this.
+
+5. **Update as you go**: If your implementation diverges from the plan, use the update command to keep future tasks aligned with your current approach.
+
+6. **Break down complex tasks**: Use the expand command to break down complex tasks into manageable subtasks.
+
+7. **Regenerate task files**: After any updates to tasks.json, regenerate the task files to keep them in sync.
+
+8. **Communicate context to the agent**: When asking the Cursor agent to help with a task, provide context about what you're trying to achieve.
+
+9. **Validate dependencies**: Periodically run the validate-dependencies command to check for invalid or circular dependencies.

docs/tutorial.md

@@ -0,0 +1,371 @@
+# Task Master Tutorial
+
+This tutorial will guide you through setting up and using Task Master for AI-driven development.
+
+## Initial Setup
+
+There are two ways to set up Task Master: using MCP (recommended) or via npm installation.
+
+### Option 1: Using MCP (Recommended)
+
+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):
+
+```json
+{
+	"mcpServers": {
+		"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"
+			}
+		}
+	}
+}
+```
+
+**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
+
+**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:
+
+```
+Can you please initialize taskmaster-ai into my project?
+```
+
+The AI will:
+
+- Create necessary project structure
+- 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`)
+
+6. **Use natural language commands** to interact with Task Master:
+
+```
+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?
+```
+
+### Option 2: Manual Installation
+
+If you prefer to use the command line interface directly:
+
+```bash
+# Install globally
+npm install -g task-master-ai
+
+# OR install locally within your project
+npm install task-master-ai
+```
+
+Initialize a new project:
+
+```bash
+# If installed globally
+task-master init
+
+# If installed locally
+npx task-master init
+```
+
+This will prompt you for project details and set up a new project with the necessary files and structure.
+
+## Common Commands
+
+After setting up Task Master, you can use these commands (either via AI prompts or CLI):
+
+```bash
+# Parse a PRD and generate tasks
+task-master parse-prd your-prd.txt
+
+# List all tasks
+task-master list
+
+# Show the next task to work on
+task-master next
+
+# Generate task files
+task-master generate
+```
+
+## Setting up Cursor AI Integration
+
+Task Master is designed to work seamlessly with [Cursor AI](https://www.cursor.so/), providing a structured workflow for AI-driven development.
+
+### Using Cursor with MCP (Recommended)
+
+If you've already set up Task Master with MCP in Cursor, the integration is automatic. You can simply use natural language to interact with Task Master:
+
+```
+What tasks are available to work on next?
+Can you analyze the complexity of our tasks?
+I'd like to implement task 4. What does it involve?
+```
+
+### Manual Cursor Setup
+
+If you're not using MCP, you can still set up Cursor integration:
+
+1. After initializing your project, open it in Cursor
+2. The `.cursor/rules/dev_workflow.mdc` file is automatically loaded by Cursor, providing the AI with knowledge about the task management system
+3. Place your PRD document in the `scripts/` directory (e.g., `scripts/prd.txt`)
+4. Open Cursor's AI chat and switch to Agent mode
+
+### Alternative MCP Setup in Cursor
+
+You can also set up the MCP server in Cursor settings:
+
+1. Go to Cursor settings
+2. Navigate to the MCP section
+3. Click on "Add New MCP Server"
+4. Configure with the following details:
+   - Name: "Task Master"
+   - Type: "Command"
+   - Command: "npx -y --package=task-master-ai task-master-ai"
+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.
+
+## Initial Task Generation
+
+In Cursor's AI chat, instruct the agent to generate tasks from your PRD:
+
+```
+Please use the task-master parse-prd command to generate tasks from my PRD. The PRD is located at scripts/prd.txt.
+```
+
+The agent will execute:
+
+```bash
+task-master parse-prd scripts/prd.txt
+```
+
+This will:
+
+- Parse your PRD document
+- Generate a structured `tasks.json` file with tasks, dependencies, priorities, and test strategies
+- The agent will understand this process due to the Cursor rules
+
+### Generate Individual Task Files
+
+Next, ask the agent to generate individual task files:
+
+```
+Please generate individual task files from tasks.json
+```
+
+The agent will execute:
+
+```bash
+task-master generate
+```
+
+This creates individual task files in the `tasks/` directory (e.g., `task_001.txt`, `task_002.txt`), making it easier to reference specific tasks.
+
+## AI-Driven Development Workflow
+
+The Cursor agent is pre-configured (via the rules file) to follow this workflow:
+
+### 1. Task Discovery and Selection
+
+Ask the agent to list available tasks:
+
+```
+What tasks are available to work on next?
+```
+
+The agent will:
+
+- Run `task-master list` to see all tasks
+- Run `task-master next` to determine the next task to work on
+- Analyze dependencies to determine which tasks are ready to be worked on
+- Prioritize tasks based on priority level and ID order
+- Suggest the next task(s) to implement
+
+### 2. Task Implementation
+
+When implementing a task, the agent will:
+
+- Reference the task's details section for implementation specifics
+- Consider dependencies on previous tasks
+- Follow the project's coding standards
+- Create appropriate tests based on the task's testStrategy
+
+You can ask:
+
+```
+Let's implement task 3. What does it involve?
+```
+
+### 3. Task Verification
+
+Before marking a task as complete, verify it according to:
+
+- The task's specified testStrategy
+- Any automated tests in the codebase
+- Manual verification if required
+
+### 4. Task Completion
+
+When a task is completed, tell the agent:
+
+```
+Task 3 is now complete. Please update its status.
+```
+
+The agent will execute:
+
+```bash
+task-master set-status --id=3 --status=done
+```
+
+### 5. Handling Implementation Drift
+
+If during implementation, you discover that:
+
+- The current approach differs significantly from what was planned
+- Future tasks need to be modified due to current implementation choices
+- New dependencies or requirements have emerged
+
+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?
+```
+
+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
+```
+
+This will rewrite or re-scope subsequent tasks in tasks.json while preserving completed work.
+
+### 6. Breaking Down Complex Tasks
+
+For complex tasks that need more granularity:
+
+```
+Task 5 seems complex. Can you break it down into subtasks?
+```
+
+The agent will execute:
+
+```bash
+task-master expand --id=5 --num=3
+```
+
+You can provide additional context:
+
+```
+Please break down task 5 with a focus on security considerations.
+```
+
+The agent will execute:
+
+```bash
+task-master expand --id=5 --prompt="Focus on security aspects"
+```
+
+You can also expand all pending tasks:
+
+```
+Please break down all pending tasks into subtasks.
+```
+
+The agent will execute:
+
+```bash
+task-master expand --all
+```
+
+For research-backed subtask generation using the configured research model:
+
+```
+Please break down task 5 using research-backed generation.
+```
+
+The agent will execute:
+
+```bash
+task-master expand --id=5 --research
+```
+
+## Example Cursor AI Interactions
+
+### Starting a new project
+
+```
+I've just initialized a new project with Claude Task Master. I have a PRD at scripts/prd.txt.
+Can you help me parse it and set up the initial tasks?
+```
+
+### Working on tasks
+
+```
+What's the next task I should work on? Please consider dependencies and priorities.
+```
+
+### Implementing a specific task
+
+```
+I'd like to implement task 4. Can you help me understand what needs to be done and how to approach it?
+```
+
+### Managing subtasks
+
+```
+I need to regenerate the subtasks for task 3 with a different approach. Can you help me clear and regenerate them?
+```
+
+### Handling changes
+
+```
+We've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks to reflect this change?
+```
+
+### Completing work
+
+```
+I've finished implementing the authentication system described in task 2. All tests are passing.
+Please mark it as complete and tell me what I should work on next.
+```
+
+### Analyzing complexity
+
+```
+Can you analyze the complexity of our tasks to help me understand which ones need to be broken down further?
+```
+
+### Viewing complexity report
+
+```
+Can you show me the complexity report in a more readable format?
+```

index.js

@@ -46,22 +46,18 @@ export const initProject = async (options = {}) => {
 };
 
 // Export a function to run init as a CLI command
-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 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 version information
@@ -79,11 +75,21 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 	program
 		.command('init')
 		.description('Initialize a new project')
-    .action(() => {
-      runInitCLI().catch(err => {
+		.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) {
 				console.error('Init failed:', err.message);
 				process.exit(1);
-      });
+			}
 		});
 
 	program

jest.config.js

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

mcp-server/server.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-import TaskMasterMCPServer from "./src/index.js";
-import dotenv from "dotenv";
-import logger from "./src/logger.js";
+import TaskMasterMCPServer from './src/index.js';
+import dotenv from 'dotenv';
+import logger from './src/logger.js';
 
 // Load environment variables
 dotenv.config();
@@ -14,12 +14,12 @@ async function startServer() {
 	const server = new TaskMasterMCPServer();
 
 	// Handle graceful shutdown
-  process.on("SIGINT", async () => {
+	process.on('SIGINT', async () => {
 		await server.stop();
 		process.exit(0);
 	});
 
-  process.on("SIGTERM", async () => {
+	process.on('SIGTERM', async () => {
 		await server.stop();
 		process.exit(0);
 	});

mcp-server/src/core/__tests__/context-manager.test.js

@@ -14,7 +14,9 @@ describe('ContextManager', () => {
 
 	describe('getContext', () => {
 		it('should create a new context when not in cache', async () => {
-      const context = await contextManager.getContext('test-id', { test: true });
+			const context = await contextManager.getContext('test-id', {
+				test: true
+			});
 			expect(context.id).toBe('test-id');
 			expect(context.metadata.test).toBe(true);
 			expect(contextManager.stats.misses).toBe(1);
@@ -26,7 +28,9 @@ describe('ContextManager', () => {
 			await contextManager.getContext('test-id', { test: true });
 
 			// Second call should hit cache
-      const context = await contextManager.getContext('test-id', { test: true });
+			const context = await contextManager.getContext('test-id', {
+				test: true
+			});
 			expect(context.id).toBe('test-id');
 			expect(context.metadata.test).toBe(true);
 			expect(contextManager.stats.hits).toBe(1);
@@ -38,7 +42,7 @@ describe('ContextManager', () => {
 			await contextManager.getContext('test-id', { test: true });
 
 			// Wait for TTL to expire
-      await new Promise(resolve => setTimeout(resolve, 1100));
+			await new Promise((resolve) => setTimeout(resolve, 1100));
 
 			// Should create new context
 			await contextManager.getContext('test-id', { test: true });
@@ -50,7 +54,9 @@ describe('ContextManager', () => {
 	describe('updateContext', () => {
 		it('should update existing context metadata', async () => {
 			await contextManager.getContext('test-id', { initial: true });
-      const updated = await contextManager.updateContext('test-id', { updated: true });
+			const updated = await contextManager.updateContext('test-id', {
+				updated: true
+			});
 
 			expect(updated.metadata.initial).toBe(true);
 			expect(updated.metadata.updated).toBe(true);

mcp-server/src/core/context-manager.js

@@ -112,7 +112,8 @@ export class ContextManager {
 	 */
 	getCachedData(key) {
 		const cached = this.cache.get(key);
-    if (cached !== undefined) { // Check for undefined specifically, as null/false might be valid cached values
+		if (cached !== undefined) {
+			// Check for undefined specifically, as null/false might be valid cached values
 			this.stats.hits++;
 			return cached;
 		}

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

@@ -0,0 +1,106 @@
+/**
+ * add-dependency.js
+ * Direct function implementation for adding a dependency to a task
+ */
+
+import { addDependency } from '../../../../scripts/modules/dependency-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * 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 {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) {
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: 'Task ID (id) is required'
+				}
+			};
+		}
+
+		if (!dependsOn) {
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: 'Dependency ID (dependsOn) is required'
+				}
+			};
+		}
+
+		// Use provided path
+		const tasksPath = tasksJsonPath;
+
+		// Format IDs for the core function
+		const taskId =
+			id && id.includes && id.includes('.') ? id : parseInt(id, 10);
+		const dependencyId =
+			dependsOn && dependsOn.includes && dependsOn.includes('.')
+				? dependsOn
+				: parseInt(dependsOn, 10);
+
+		log.info(
+			`Adding dependency: task ${taskId} will depend on ${dependencyId}`
+		);
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+
+		// Call the core function using the provided path
+		await addDependency(tasksPath, taskId, dependencyId);
+
+		// Restore normal logging
+		disableSilentMode();
+
+		return {
+			success: true,
+			data: {
+				message: `Successfully added dependency: Task ${taskId} now depends on ${dependencyId}`,
+				taskId: taskId,
+				dependencyId: dependencyId
+			}
+		};
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error in addDependencyDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'CORE_FUNCTION_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,165 @@
+/**
+ * Direct function wrapper for addSubtask
+ */
+
+import { addSubtask } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * 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)
+ * @param {string} [args.description] - Description for new subtask
+ * @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 {boolean} [args.skipGenerate] - Skip regenerating task files
+ * @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) {
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: 'Parent task ID is required'
+				}
+			};
+		}
+
+		// Either taskId or title must be provided
+		if (!taskId && !title) {
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: 'Either taskId or title must be provided'
+				}
+			};
+		}
+
+		// Use provided path
+		const tasksPath = tasksJsonPath;
+
+		// Parse dependencies if provided
+		let dependencies = [];
+		if (dependenciesStr) {
+			dependencies = dependenciesStr.split(',').map((depId) => {
+				// Handle both regular IDs and dot notation
+				return depId.includes('.') ? depId.trim() : parseInt(depId.trim(), 10);
+			});
+		}
+
+		// Convert existingTaskId to a number if provided
+		const existingTaskId = taskId ? parseInt(taskId, 10) : null;
+
+		// Convert parent ID to a number
+		const parentId = parseInt(id, 10);
+
+		// Determine if we should generate files
+		const generateFiles = !skipGenerate;
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+
+		// Case 1: Convert existing task to subtask
+		if (existingTaskId) {
+			log.info(`Converting task ${existingTaskId} to a subtask of ${parentId}`);
+			const result = await addSubtask(
+				tasksPath,
+				parentId,
+				existingTaskId,
+				null,
+				generateFiles
+			);
+
+			// Restore normal logging
+			disableSilentMode();
+
+			return {
+				success: true,
+				data: {
+					message: `Task ${existingTaskId} successfully converted to a subtask of task ${parentId}`,
+					subtask: result
+				}
+			};
+		}
+		// Case 2: Create new subtask
+		else {
+			log.info(`Creating new subtask for parent task ${parentId}`);
+
+			const newSubtaskData = {
+				title: title,
+				description: description || '',
+				details: details || '',
+				status: status || 'pending',
+				dependencies: dependencies
+			};
+
+			const result = await addSubtask(
+				tasksPath,
+				parentId,
+				null,
+				newSubtaskData,
+				generateFiles
+			);
+
+			// Restore normal logging
+			disableSilentMode();
+
+			return {
+				success: true,
+				data: {
+					message: `New subtask ${parentId}.${result.id} successfully created`,
+					subtask: result
+				}
+			};
+		}
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error in addSubtaskDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'CORE_FUNCTION_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,174 @@
+/**
+ * add-task.js
+ * Direct function implementation for adding a new task
+ */
+
+import { addTask } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+import { createLogWrapper } from '../../tools/utils.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.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 {Object} log - Logger object
+ * @param {Object} context - Additional context (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'
+				}
+			};
+		}
+
+		// Use provided path
+		const tasksPath = tasksJsonPath;
+
+		// Check if this is manual task creation or AI-driven task creation
+		const isManualCreation = args.title && args.description;
+
+		// Check required parameters
+		if (!args.prompt && !isManualCreation) {
+			log.error(
+				'Missing required parameters: either prompt or title+description must be provided'
+			);
+			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'
+				}
+			};
+		}
+
+		// 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)
+						.split(',')
+						.map((id) => parseInt(id.trim(), 10)) // Split, trim, and parse
+				: []; // Default to empty array if null/undefined
+		const taskPriority = priority || 'medium'; // Default priority
+
+		let manualTaskData = null;
+		let newTaskId;
+
+		if (isManualCreation) {
+			// Create manual task data object
+			manualTaskData = {
+				title: args.title,
+				description: args.description,
+				details: args.details || '',
+				testStrategy: args.testStrategy || ''
+			};
+
+			log.info(
+				`Adding new task manually with title: "${args.title}", dependencies: [${taskDependencies.join(', ')}], priority: ${priority}`
+			);
+
+			// Call the addTask function with manual task data
+			newTaskId = await addTask(
+				tasksPath,
+				null, // prompt is null for manual creation
+				taskDependencies,
+				taskPriority,
+				{
+					session,
+					mcpLog,
+					projectRoot
+				},
+				'json', // outputFormat
+				manualTaskData, // Pass the manual task data
+				false, // research flag is false for manual creation
+				projectRoot // Pass projectRoot
+			);
+		} 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
+			newTaskId = await addTask(
+				tasksPath,
+				prompt, // Use the prompt for AI creation
+				taskDependencies,
+				taskPriority,
+				{
+					session,
+					mcpLog,
+					projectRoot
+				},
+				'json', // outputFormat
+				null, // manualTaskData is null for AI creation
+				research // Pass the research flag
+			);
+		}
+
+		// Restore normal logging
+		disableSilentMode();
+
+		return {
+			success: true,
+			data: {
+				taskId: newTaskId,
+				message: `Successfully added new task #${newTaskId}`
+			}
+		};
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		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
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,200 @@
+/**
+ * Direct function wrapper for analyzeTaskComplexity
+ */
+
+import analyzeTaskComplexity from '../../../../scripts/modules/task-manager/analyze-task-complexity.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
+import fs from 'fs';
+import { createLogWrapper } from '../../tools/utils.js'; // Import the new utility
+
+/**
+ * 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|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.projectRoot] - Project root path.
+ * @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 } = args;
+
+	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' }
+			};
+		}
+
+		const tasksPath = tasksJsonPath;
+		const resolvedOutputPath = outputPath;
+
+		log.info(`Analyzing task complexity from: ${tasksPath}`);
+		log.info(`Output report will be saved to: ${resolvedOutputPath}`);
+
+		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,
+			output: outputPath,
+			threshold: threshold,
+			research: research === true, // Ensure boolean
+			projectRoot: projectRoot // Pass projectRoot here
+		};
+		// --- End Initial Checks ---
+
+		// --- Silent Mode and Logger Wrapper ---
+		const wasSilent = isSilentMode();
+		if (!wasSilent) {
+			enableSilentMode(); // Still enable silent mode as a backup
+		}
+
+		let report;
+
+		try {
+			// --- Call Core Function (Pass context separately) ---
+			// Pass coreOptions as the first argument
+			// Pass context object { session, mcpLog } as the second argument
+			report = await analyzeTaskComplexity(
+				coreOptions, // Pass options object
+				{ session, mcpLog: logWrapper } // Pass context object
+				// Removed the explicit 'json' format argument, assuming context handling is sufficient
+				// If issues persist, we might need to add an explicit format param to analyzeTaskComplexity
+			);
+		} catch (error) {
+			log.error(
+				`Error in analyzeTaskComplexity core function: ${error.message}`
+			);
+			// Restore logging if we changed it
+			if (!wasSilent && isSilentMode()) {
+				disableSilentMode();
+			}
+			return {
+				success: false,
+				error: {
+					code: 'ANALYZE_CORE_ERROR',
+					message: `Error running core complexity analysis: ${error.message}`
+				}
+			};
+		} finally {
+			// Always restore normal logging in finally block if we enabled silent mode
+			if (!wasSilent && isSilentMode()) {
+				disableSilentMode();
+			}
+		}
+
+		// --- Result Handling (remains largely the same) ---
+		// Verify the report file was created (core function writes it)
+		if (!fs.existsSync(resolvedOutputPath)) {
+			return {
+				success: false,
+				error: {
+					code: 'ANALYZE_REPORT_MISSING', // Specific code
+					message:
+						'Analysis completed but no report file was created at the expected path.'
+				}
+			};
+		}
+
+		// Added a check to ensure report is defined before accessing its properties
+		if (!report || typeof 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.'
+				}
+			};
+		}
+
+		try {
+			// Ensure complexityAnalysis exists and is an array
+			const analysisArray = Array.isArray(report.complexityAnalysis)
+				? report.complexityAnalysis
+				: [];
+
+			// Count tasks by complexity (remains the same)
+			const highComplexityTasks = analysisArray.filter(
+				(t) => t.complexityScore >= 8
+			).length;
+			const mediumComplexityTasks = analysisArray.filter(
+				(t) => t.complexityScore >= 5 && t.complexityScore < 8
+			).length;
+			const lowComplexityTasks = analysisArray.filter(
+				(t) => t.complexityScore < 5
+			).length;
+
+			return {
+				success: true,
+				data: {
+					message: `Task complexity analysis complete. Report saved to ${outputPath}`, // Use outputPath from args
+					reportPath: outputPath, // Use outputPath from args
+					reportSummary: {
+						taskCount: analysisArray.length,
+						highComplexityTasks,
+						mediumComplexityTasks,
+						lowComplexityTasks
+					},
+					fullReport: report // Now includes the full report
+				}
+			};
+		} catch (parseError) {
+			// Should not happen if core function returns object, but good safety check
+			log.error(`Internal error processing report data: ${parseError.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'REPORT_PROCESS_ERROR',
+					message: `Internal error processing 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
+		if (isSilentMode()) {
+			disableSilentMode();
+		}
+		log.error(`Error in analyzeTaskComplexityDirect setup: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'DIRECT_FUNCTION_SETUP_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

mcp-server/src/core/direct-functions/cache-stats.js

@@ -0,0 +1,32 @@
+/**
+ * cache-stats.js
+ * Direct function implementation for retrieving cache statistics
+ */
+
+import { contextManager } from '../context-manager.js';
+
+/**
+ * Get cache statistics for monitoring
+ * @param {Object} args - Command arguments
+ * @param {Object} log - Logger object
+ * @returns {Object} - Cache statistics
+ */
+export async function getCacheStatsDirect(args, log) {
+	try {
+		log.info('Retrieving cache statistics');
+		const stats = contextManager.getStats();
+		return {
+			success: true,
+			data: stats
+		};
+	} catch (error) {
+		log.error(`Error getting cache stats: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'CACHE_STATS_ERROR',
+				message: error.message || 'Unknown error occurred'
+			}
+		};
+	}
+}

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

@@ -0,0 +1,128 @@
+/**
+ * Direct function wrapper for clearSubtasks
+ */
+
+import { clearSubtasks } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+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 {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) {
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message:
+						'Either task IDs with id parameter or all parameter must be provided'
+				}
+			};
+		}
+
+		// Use provided path
+		const tasksPath = tasksJsonPath;
+
+		// Check if tasks.json exists
+		if (!fs.existsSync(tasksPath)) {
+			return {
+				success: false,
+				error: {
+					code: 'FILE_NOT_FOUND_ERROR',
+					message: `Tasks file not found at ${tasksPath}`
+				}
+			};
+		}
+
+		let taskIds;
+
+		// If all is specified, get all task IDs
+		if (all) {
+			log.info('Clearing subtasks from all tasks');
+			const data = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+			if (!data || !data.tasks || data.tasks.length === 0) {
+				return {
+					success: false,
+					error: {
+						code: 'INPUT_VALIDATION_ERROR',
+						message: 'No valid tasks found in the tasks file'
+					}
+				};
+			}
+			taskIds = data.tasks.map((t) => t.id).join(',');
+		} else {
+			// Use the provided task IDs
+			taskIds = id;
+		}
+
+		log.info(`Clearing subtasks from tasks: ${taskIds}`);
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+
+		// Call the core function
+		clearSubtasks(tasksPath, taskIds);
+
+		// Restore normal logging
+		disableSilentMode();
+
+		// Read the updated data to provide a summary
+		const updatedData = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+		const taskIdArray = taskIds.split(',').map((id) => parseInt(id.trim(), 10));
+
+		// Build a summary of what was done
+		const clearedTasksCount = taskIdArray.length;
+		const taskSummary = taskIdArray.map((id) => {
+			const task = updatedData.tasks.find((t) => t.id === id);
+			return task ? { id, title: task.title } : { id, title: 'Task not found' };
+		});
+
+		return {
+			success: true,
+			data: {
+				message: `Successfully cleared subtasks from ${clearedTasksCount} task(s)`,
+				tasksCleared: taskSummary
+			}
+		};
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error in clearSubtasksDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'CORE_FUNCTION_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,129 @@
+/**
+ * complexity-report.js
+ * Direct function implementation for displaying complexity analysis report
+ */
+
+import {
+	readComplexityReport,
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
+
+/**
+ * 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} 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
+			};
+		}
+
+		// Use the provided report path
+		log.info(`Looking for complexity report at: ${reportPath}`);
+
+		// Generate cache key based on report path
+		const cacheKey = `complexityReport:${reportPath}`;
+
+		// Define the core action function to read the report
+		const coreActionFn = async () => {
+			try {
+				// Enable silent mode to prevent console logs from interfering with JSON response
+				enableSilentMode();
+
+				const report = readComplexityReport(reportPath);
+
+				// Restore normal logging
+				disableSilentMode();
+
+				if (!report) {
+					log.warn(`No complexity report found at ${reportPath}`);
+					return {
+						success: false,
+						error: {
+							code: 'FILE_NOT_FOUND_ERROR',
+							message: `No complexity report found at ${reportPath}. Run 'analyze-complexity' first.`
+						}
+					};
+				}
+
+				return {
+					success: true,
+					data: {
+						report,
+						reportPath
+					}
+				};
+			} catch (error) {
+				// Make sure to restore normal logging even if there's an error
+				disableSilentMode();
+
+				log.error(`Error reading complexity report: ${error.message}`);
+				return {
+					success: false,
+					error: {
+						code: 'READ_ERROR',
+						message: error.message
+					}
+				};
+			}
+		};
+
+		// Use the caching utility
+		try {
+			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 getCachedOrExecute for complexityReport: ${error.message}`
+			);
+			return {
+				success: false,
+				error: {
+					code: 'UNEXPECTED_ERROR',
+					message: error.message
+				},
+				fromCache: false
+			};
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled if an outer error occurs
+		disableSilentMode();
+
+		log.error(`Error in complexityReportDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'UNEXPECTED_ERROR',
+				message: error.message
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Direct function wrapper for expandAllTasks
+ */
+
+import { expandAllTasks } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+import { createLogWrapper } from '../../tools/utils.js';
+
+/**
+ * Expand all pending tasks with subtasks (Direct Function Wrapper)
+ * @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 {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 {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;
+
+	// 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 })}`
+		);
+
+		// Parse parameters (ensure correct types)
+		const numSubtasks = num ? parseInt(num, 10) : undefined;
+		const useResearch = research === true;
+		const additionalContext = prompt || '';
+		const forceFlag = force === true;
+
+		// 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 }
+		);
+
+		// Core function now returns a summary object
+		return {
+			success: true,
+			data: {
+				message: `Expand all operation completed. Expanded: ${result.expandedCount}, Failed: ${result.failedCount}, Skipped: ${result.skippedCount}`,
+				details: result // Include the full result details
+			}
+		};
+	} 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); }
+
+		return {
+			success: false,
+			error: {
+				code: 'CORE_FUNCTION_ERROR', // Or a more specific code if possible
+				message: error.message
+			}
+		};
+	} finally {
+		disableSilentMode(); // IMPORTANT: Ensure silent mode is always disabled
+	}
+}

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

@@ -0,0 +1,256 @@
+/**
+ * expand-task.js
+ * Direct function implementation for expanding a task into subtasks
+ */
+
+import expandTask from '../../../../scripts/modules/task-manager/expand-task.js';
+import {
+	readJSON,
+	writeJSON,
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/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
+ * @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;
+
+	// Log session root data for debugging
+	log.info(
+		`Session data in expandTaskDirect: ${JSON.stringify({
+			hasSession: !!session,
+			sessionKeys: session ? Object.keys(session) : [],
+			roots: session?.roots,
+			rootsStr: JSON.stringify(session?.roots)
+		})}`
+	);
+
+	// Check if tasksJsonPath was provided
+	if (!tasksJsonPath) {
+		log.error('expandTaskDirect called without tasksJsonPath');
+		return {
+			success: false,
+			error: {
+				code: 'MISSING_ARGUMENT',
+				message: 'tasksJsonPath is required'
+			},
+			fromCache: false
+		};
+	}
+
+	// Use provided path
+	const tasksPath = tasksJsonPath;
+
+	log.info(`[expandTaskDirect] Using tasksPath: ${tasksPath}`);
+
+	// Validate task ID
+	const taskId = id ? parseInt(id, 10) : null;
+	if (!taskId) {
+		log.error('Task ID is required');
+		return {
+			success: false,
+			error: {
+				code: 'INPUT_VALIDATION_ERROR',
+				message: 'Task ID is required'
+			},
+			fromCache: false
+		};
+	}
+
+	// Process other parameters
+	const numSubtasks = num ? parseInt(num, 10) : undefined;
+	const useResearch = research === true;
+	const additionalContext = prompt || '';
+	const forceFlag = force === true;
+
+	try {
+		log.info(
+			`[expandTaskDirect] Expanding task ${taskId} into ${numSubtasks || 'default'} subtasks. Research: ${useResearch}, Force: ${forceFlag}`
+		);
+
+		// Read tasks data
+		log.info(`[expandTaskDirect] Attempting to read JSON from: ${tasksPath}`);
+		const data = readJSON(tasksPath);
+		log.info(
+			`[expandTaskDirect] Result of readJSON: ${data ? 'Data read successfully' : 'readJSON returned null or undefined'}`
+		);
+
+		if (!data || !data.tasks) {
+			log.error(
+				`[expandTaskDirect] readJSON failed or returned invalid data for path: ${tasksPath}`
+			);
+			return {
+				success: false,
+				error: {
+					code: 'INVALID_TASKS_FILE',
+					message: `No valid tasks found in ${tasksPath}. readJSON returned: ${JSON.stringify(data)}`
+				},
+				fromCache: false
+			};
+		}
+
+		// Find the specific task
+		log.info(`[expandTaskDirect] Searching for task ID ${taskId} in data`);
+		const task = data.tasks.find((t) => t.id === taskId);
+		log.info(`[expandTaskDirect] Task found: ${task ? 'Yes' : 'No'}`);
+
+		if (!task) {
+			return {
+				success: false,
+				error: {
+					code: 'TASK_NOT_FOUND',
+					message: `Task with ID ${taskId} not found`
+				},
+				fromCache: false
+			};
+		}
+
+		// Check if task is completed
+		if (task.status === 'done' || task.status === 'completed') {
+			return {
+				success: false,
+				error: {
+					code: 'TASK_COMPLETED',
+					message: `Task ${taskId} is already marked as ${task.status} and cannot be expanded`
+				},
+				fromCache: false
+			};
+		}
+
+		// Check for existing subtasks and force flag
+		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.`
+			);
+			return {
+				success: true,
+				data: {
+					message: `Task ${taskId} already has subtasks. Expansion skipped.`,
+					task,
+					subtasksAdded: 0,
+					hasExistingSubtasks
+				},
+				fromCache: false
+			};
+		}
+
+		// 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));
+
+		// Tracking subtasks count before expansion
+		const subtasksCountBefore = task.subtasks ? task.subtasks.length : 0;
+
+		// Create a backup of the tasks.json file
+		const backupPath = path.join(path.dirname(tasksPath), 'tasks.json.bak');
+		fs.copyFileSync(tasksPath, backupPath);
+
+		// Directly modify the data instead of calling the CLI function
+		if (!task.subtasks) {
+			task.subtasks = [];
+		}
+
+		// 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();
+
+			// Call the core expandTask function with the wrapped logger and projectRoot
+			const updatedTaskResult = await expandTask(
+				tasksPath,
+				taskId,
+				numSubtasks,
+				useResearch,
+				additionalContext,
+				{ mcpLog, session, projectRoot },
+				forceFlag
+			);
+
+			// Restore normal logging
+			if (!wasSilent && isSilentMode()) disableSilentMode();
+
+			// Read the updated data
+			const updatedData = readJSON(tasksPath);
+			const updatedTask = updatedData.tasks.find((t) => t.id === taskId);
+
+			// Calculate how many subtasks were added
+			const subtasksAdded = updatedTask.subtasks
+				? updatedTask.subtasks.length - subtasksCountBefore
+				: 0;
+
+			// Return the result
+			log.info(
+				`Successfully expanded task ${taskId} with ${subtasksAdded} new subtasks`
+			);
+			return {
+				success: true,
+				data: {
+					task: updatedTask,
+					subtasksAdded,
+					hasExistingSubtasks
+				},
+				fromCache: false
+			};
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			if (!wasSilent && isSilentMode()) disableSilentMode();
+
+			log.error(`Error expanding task: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'CORE_FUNCTION_ERROR',
+					message: error.message || 'Failed to expand task'
+				},
+				fromCache: false
+			};
+		}
+	} catch (error) {
+		log.error(`Error expanding task: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'CORE_FUNCTION_ERROR',
+				message: error.message || 'Failed to expand task'
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Direct function wrapper for fixDependenciesCommand
+ */
+
+import { fixDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+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 {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}`);
+
+		// 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;
+
+		// Verify the file exists
+		if (!fs.existsSync(tasksPath)) {
+			return {
+				success: false,
+				error: {
+					code: 'FILE_NOT_FOUND',
+					message: `Tasks file not found at ${tasksPath}`
+				}
+			};
+		}
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+
+		// Call the original command function using the provided path
+		await fixDependenciesCommand(tasksPath);
+
+		// Restore normal logging
+		disableSilentMode();
+
+		return {
+			success: true,
+			data: {
+				message: 'Dependencies fixed successfully',
+				tasksPath
+			}
+		};
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error fixing dependencies: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'FIX_DEPENDENCIES_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,99 @@
+/**
+ * generate-task-files.js
+ * Direct function implementation for generating task files from tasks.json
+ */
+
+import { generateTaskFiles } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * Direct function wrapper for generateTaskFiles with error handling.
+ *
+ * @param {Object} args - Command arguments containing tasksJsonPath and outputDir.
+ * @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);
+			return {
+				success: false,
+				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
+				fromCache: false
+			};
+		}
+		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
+			};
+		}
+
+		// Use the provided paths
+		const tasksPath = tasksJsonPath;
+		const resolvedOutputDir = outputDir;
+
+		log.info(`Generating task files from ${tasksPath} to ${resolvedOutputDir}`);
+
+		// Execute core generateTaskFiles function in a separate try/catch
+		try {
+			// Enable silent mode to prevent logs from being written to stdout
+			enableSilentMode();
+
+			// The function is synchronous despite being awaited elsewhere
+			generateTaskFiles(tasksPath, resolvedOutputDir);
+
+			// Restore normal logging after task generation
+			disableSilentMode();
+		} catch (genError) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+
+			log.error(`Error in generateTaskFiles: ${genError.message}`);
+			return {
+				success: false,
+				error: { code: 'GENERATE_FILES_ERROR', message: genError.message },
+				fromCache: false
+			};
+		}
+
+		// Return success with file paths
+		return {
+			success: true,
+			data: {
+				message: `Successfully generated task files`,
+				tasksPath: tasksPath,
+				outputDir: resolvedOutputDir,
+				taskFiles:
+					'Individual task files have been generated in the output directory'
+			},
+			fromCache: false // This operation always modifies state and should never be cached
+		};
+	} catch (error) {
+		// Make sure to restore normal logging if an outer error occurs
+		disableSilentMode();
+
+		log.error(`Error generating task files: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'GENERATE_TASKS_ERROR',
+				message: error.message || 'Unknown error generating task files'
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,112 @@
+/**
+ * list-tasks.js
+ * Direct function implementation for listing tasks
+ */
+
+import { listTasks } from '../../../../scripts/modules/task-manager.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * Direct function wrapper for listTasks with error handling and caching.
+ *
+ * @param {Object} args - Command arguments (now expecting tasksJsonPath explicitly).
+ * @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, status, withSubtasks } = args;
+
+	if (!tasksJsonPath) {
+		log.error('listTasksDirect called without tasksJsonPath');
+		return {
+			success: false,
+			error: {
+				code: 'MISSING_ARGUMENT',
+				message: 'tasksJsonPath is required'
+			},
+			fromCache: false
+		};
+	}
+
+	// Use the explicit tasksJsonPath for cache key
+	const statusFilter = status || 'all';
+	const withSubtasksFilter = withSubtasks || false;
+	const cacheKey = `listTasks:${tasksJsonPath}:${statusFilter}:${withSubtasksFilter}`;
+
+	// Define the action function to be executed on cache miss
+	const coreListTasksAction = async () => {
+		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
+
+			log.info(
+				`Executing core listTasks function for path: ${tasksJsonPath}, filter: ${statusFilter}, subtasks: ${withSubtasksFilter}`
+			);
+			// Pass the explicit tasksJsonPath to the core function
+			const resultData = listTasks(
+				tasksJsonPath,
+				statusFilter,
+				withSubtasksFilter,
+				'json'
+			);
+
+			if (!resultData || !resultData.tasks) {
+				log.error('Invalid or empty response from listTasks core function');
+				return {
+					success: false,
+					error: {
+						code: 'INVALID_CORE_RESPONSE',
+						message: 'Invalid or empty response from listTasks core function'
+					}
+				};
+			}
+			log.info(
+				`Core listTasks function retrieved ${resultData.tasks.length} tasks`
+			);
+
+			// Restore normal logging
+			disableSilentMode();
+
+			return { success: true, data: resultData };
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+
+			log.error(`Core listTasks function failed: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'LIST_TASKS_CORE_ERROR',
+					message: error.message || 'Failed to list tasks'
+				}
+			};
+		}
+	};
+
+	// Use the caching utility
+	try {
+		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) {
+		// 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: 'CACHE_UTIL_ERROR', message: error.message },
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,121 @@
+/**
+ * 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/next-task.js

@@ -0,0 +1,142 @@
+/**
+ * next-task.js
+ * Direct function implementation for finding the next task to work on
+ */
+
+import { findNextTask } from '../../../../scripts/modules/task-manager.js';
+import { readJSON } from '../../../../scripts/modules/utils.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * 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 } = args;
+
+	if (!tasksJsonPath) {
+		log.error('nextTaskDirect called without tasksJsonPath');
+		return {
+			success: false,
+			error: {
+				code: 'MISSING_ARGUMENT',
+				message: 'tasksJsonPath is required'
+			},
+			fromCache: false
+		};
+	}
+
+	// Generate cache key using the provided task path
+	const cacheKey = `nextTask:${tasksJsonPath}`;
+
+	// 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}`);
+
+			// Read tasks data using the provided path
+			const data = readJSON(tasksJsonPath);
+			if (!data || !data.tasks) {
+				disableSilentMode(); // Disable before return
+				return {
+					success: false,
+					error: {
+						code: 'INVALID_TASKS_FILE',
+						message: `No valid tasks found in ${tasksJsonPath}`
+					}
+				};
+			}
+
+			// Find the next task
+			const nextTask = findNextTask(data.tasks);
+
+			if (!nextTask) {
+				log.info(
+					'No eligible next task found. All tasks are either completed or have unsatisfied dependencies'
+				);
+				return {
+					success: true,
+					data: {
+						message:
+							'No eligible next task found. All tasks are either completed or have unsatisfied dependencies',
+						nextTask: null
+					}
+				};
+			}
+
+			// 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}`
+			);
+			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}`
+				}
+			};
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+
+			log.error(`Error finding next task: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'CORE_FUNCTION_ERROR',
+					message: error.message || 'Failed to find next task'
+				}
+			};
+		}
+	};
+
+	// Use the caching utility
+	try {
+		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) {
+		// Catch unexpected errors from getCachedOrExecute itself
+		log.error(
+			`Unexpected error during getCachedOrExecute for nextTask: ${error.message}`
+		);
+		return {
+			success: false,
+			error: {
+				code: 'UNEXPECTED_ERROR',
+				message: error.message
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,180 @@
+/**
+ * parse-prd.js
+ * Direct function implementation for parsing PRD documents
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { parsePRD } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
+import { createLogWrapper } from '../../tools/utils.js';
+import { getDefaultNumTasks } from '../../../../scripts/modules/config-manager.js';
+
+/**
+ * Direct function wrapper for parsing PRD documents and generating tasks.
+ *
+ * @param {Object} args - Command arguments containing projectRoot, input, output, numTasks 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,
+		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}`
+			);
+		}
+	}
+
+	const useForce = force === true;
+	const useAppend = append === true;
+	if (useAppend) {
+		logWrapper.info('Append mode enabled.');
+		if (useForce) {
+			logWrapper.warn(
+				'Both --force and --append flags were provided. --force takes precedence; append mode will be ignored.'
+			);
+		}
+	}
+
+	logWrapper.info(
+		`Parsing PRD via direct function. Input: ${inputPath}, Output: ${outputPath}, NumTasks: ${numTasks}, Force: ${useForce}, Append: ${useAppend}, ProjectRoot: ${projectRoot}`
+	);
+
+	const wasSilent = isSilentMode();
+	if (!wasSilent) {
+		enableSilentMode();
+	}
+
+	try {
+		// Call the core parsePRD function
+		const result = await parsePRD(
+			inputPath,
+			outputPath,
+			numTasks,
+			{ session, mcpLog: logWrapper, projectRoot, useForce, useAppend },
+			'json'
+		);
+
+		// parsePRD returns { success: true, tasks: processedTasks } on success
+		if (result && result.success && Array.isArray(result.tasks)) {
+			logWrapper.success(
+				`Successfully parsed PRD. Generated ${result.tasks.length} tasks.`
+			);
+			return {
+				success: true,
+				data: {
+					message: `Successfully parsed PRD and generated ${result.tasks.length} tasks.`,
+					outputPath: outputPath,
+					taskCount: result.tasks.length
+				}
+			};
+		} else {
+			// Handle case where core function didn't return expected success structure
+			logWrapper.error(
+				'Core parsePRD function did not return a successful structure.'
+			);
+			return {
+				success: false,
+				error: {
+					code: 'CORE_FUNCTION_ERROR',
+					message:
+						result?.message ||
+						'Core function failed to parse PRD or returned unexpected result.'
+				}
+			};
+		}
+	} catch (error) {
+		logWrapper.error(`Error executing core parsePRD: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'PARSE_PRD_CORE_ERROR',
+				message: error.message || 'Unknown error parsing PRD'
+			}
+		};
+	} finally {
+		if (!wasSilent && isSilentMode()) {
+			disableSilentMode();
+		}
+	}
+}

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

@@ -0,0 +1,104 @@
+/**
+ * Direct function wrapper for removeDependency
+ */
+
+import { removeDependency } from '../../../../scripts/modules/dependency-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * 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 {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) {
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: 'Task ID (id) is required'
+				}
+			};
+		}
+
+		if (!dependsOn) {
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: 'Dependency ID (dependsOn) is required'
+				}
+			};
+		}
+
+		// Use provided path
+		const tasksPath = tasksJsonPath;
+
+		// Format IDs for the core function
+		const taskId =
+			id && id.includes && id.includes('.') ? id : parseInt(id, 10);
+		const dependencyId =
+			dependsOn && dependsOn.includes && dependsOn.includes('.')
+				? dependsOn
+				: parseInt(dependsOn, 10);
+
+		log.info(
+			`Removing dependency: task ${taskId} no longer depends on ${dependencyId}`
+		);
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+
+		// Call the core function using the provided tasksPath
+		await removeDependency(tasksPath, taskId, dependencyId);
+
+		// Restore normal logging
+		disableSilentMode();
+
+		return {
+			success: true,
+			data: {
+				message: `Successfully removed dependency: Task ${taskId} no longer depends on ${dependencyId}`,
+				taskId: taskId,
+				dependencyId: dependencyId
+			}
+		};
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error in removeDependencyDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'CORE_FUNCTION_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,122 @@
+/**
+ * Direct function wrapper for removeSubtask
+ */
+
+import { removeSubtask } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * 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 {boolean} [args.skipGenerate] - Skip regenerating task files
+ * @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
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message:
+						'Subtask ID is required and must be in format "parentId.subtaskId"'
+				}
+			};
+		}
+
+		// Validate subtask ID format
+		if (!id.includes('.')) {
+			disableSilentMode(); // Disable before returning
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: `Invalid subtask ID format: ${id}. Expected format: "parentId.subtaskId"`
+				}
+			};
+		}
+
+		// Use provided path
+		const tasksPath = tasksJsonPath;
+
+		// Convert convertToTask to a boolean
+		const convertToTask = convert === true;
+
+		// Determine if we should generate files
+		const generateFiles = !skipGenerate;
+
+		log.info(
+			`Removing subtask ${id} (convertToTask: ${convertToTask}, generateFiles: ${generateFiles})`
+		);
+
+		// Use the provided tasksPath
+		const result = await removeSubtask(
+			tasksPath,
+			id,
+			convertToTask,
+			generateFiles
+		);
+
+		// Restore normal logging
+		disableSilentMode();
+
+		if (convertToTask && result) {
+			// Return info about the converted task
+			return {
+				success: true,
+				data: {
+					message: `Subtask ${id} successfully converted to task #${result.id}`,
+					task: result
+				}
+			};
+		} else {
+			// Return simple success message for deletion
+			return {
+				success: true,
+				data: {
+					message: `Subtask ${id} successfully removed`
+				}
+			};
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled even if an outer error occurs
+		disableSilentMode();
+
+		log.error(`Error in removeSubtaskDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'CORE_FUNCTION_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,168 @@
+/**
+ * remove-task.js
+ * Direct function implementation for removing a task
+ */
+
+import {
+	removeTask,
+	taskExists
+} from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	readJSON
+} from '../../../../scripts/modules/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');
+			return {
+				success: false,
+				error: {
+					code: 'MISSING_ARGUMENT',
+					message: 'tasksJsonPath is required'
+				},
+				fromCache: false
+			};
+		}
+
+		// Validate task ID parameter
+		if (!id) {
+			log.error('Task ID is required');
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_VALIDATION_ERROR',
+					message: 'Task ID is required'
+				},
+				fromCache: false
+			};
+		}
+
+		// 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();
+
+		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 {
+			// 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);
+
+		if (successfulRemovals.length === 0) {
+			// All removals failed
+			return {
+				success: false,
+				error: {
+					code: 'REMOVE_TASK_ERROR',
+					message: 'Failed to remove any tasks',
+					details: failedRemovals
+						.map((r) => `${r.taskId}: ${r.error}`)
+						.join('; ')
+				},
+				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();
+
+		// Catch any unexpected errors
+		log.error(`Unexpected error in removeTaskDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'UNEXPECTED_ERROR',
+				message: error.message
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,119 @@
+/**
+ * set-task-status.js
+ * Direct function implementation for setting task status
+ */
+
+import { setTaskStatus } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
+
+/**
+ * Direct function wrapper for setTaskStatus with error handling.
+ *
+ * @param {Object} args - Command arguments containing id, status and tasksJsonPath.
+ * @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 } = 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) {
+			const errorMessage =
+				'No task ID specified. Please provide a task ID to update.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_TASK_ID', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		if (!status) {
+			const errorMessage =
+				'No status specified. Please provide a new status value.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_STATUS', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Use the provided path
+		const tasksPath = tasksJsonPath;
+
+		// Execute core setTaskStatus function
+		const taskId = id;
+		const newStatus = status;
+
+		log.info(`Setting task ${taskId} status to "${newStatus}"`);
+
+		// Call the core function with proper silent mode handling
+		enableSilentMode(); // Enable silent mode before calling core function
+		try {
+			// Call the core function
+			await setTaskStatus(tasksPath, taskId, newStatus, { mcpLog: log });
+
+			log.info(`Successfully set task ${taskId} status to ${newStatus}`);
+
+			// Return success data
+			const result = {
+				success: true,
+				data: {
+					message: `Successfully updated task ${taskId} status to "${newStatus}"`,
+					taskId,
+					status: newStatus,
+					tasksPath: tasksPath // Return the path used
+				},
+				fromCache: false // This operation always modifies state and should never be cached
+			};
+			return result;
+		} catch (error) {
+			log.error(`Error setting task status: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'SET_STATUS_ERROR',
+					message: error.message || 'Unknown error setting task status'
+				},
+				fromCache: false
+			};
+		} finally {
+			// ALWAYS restore normal logging in finally block
+			disableSilentMode();
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled if there was an uncaught error in the outer try block
+		if (isSilentMode()) {
+			disableSilentMode();
+		}
+
+		log.error(`Error setting task status: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'SET_STATUS_ERROR',
+				message: error.message || 'Unknown error setting task status'
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,102 @@
+/**
+ * show-task.js
+ * Direct function implementation for showing task details
+ */
+
+import { findTaskById, readJSON } from '../../../../scripts/modules/utils.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+
+/**
+ * Direct function wrapper for getting task details.
+ *
+ * @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.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.
+ */
+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, 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;
+	try {
+		// Use the projectRoot passed directly from args
+		tasksJsonPath = findTasksJsonPath(
+			{ projectRoot: projectRoot, file: file },
+			log
+		);
+		log.info(`Resolved tasks path: ${tasksJsonPath}`);
+	} catch (error) {
+		log.error(`Error finding tasks.json: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'TASKS_FILE_NOT_FOUND',
+				message: `Failed to find tasks.json: ${error.message}`
+			}
+		};
+	}
+	// --- End Path Resolution ---
+
+	// --- Rest of the function remains the same, using tasksJsonPath ---
+	try {
+		const tasksData = readJSON(tasksJsonPath);
+		if (!tasksData || !tasksData.tasks) {
+			return {
+				success: false,
+				error: { code: 'INVALID_TASKS_DATA', message: 'Invalid tasks data' }
+			};
+		}
+
+		const { task, originalSubtaskCount } = findTaskById(
+			tasksData.tasks,
+			id,
+			status
+		);
+
+		if (!task) {
+			return {
+				success: false,
+				error: {
+					code: 'TASK_NOT_FOUND',
+					message: `Task or subtask with ID ${id} not found`
+				}
+			};
+		}
+
+		log.info(`Successfully retrieved task ${id}.`);
+
+		const returnData = { ...task };
+		if (originalSubtaskCount !== null) {
+			returnData._originalSubtaskCount = originalSubtaskCount;
+			returnData._subtaskFilter = status;
+		}
+
+		return { success: true, data: returnData };
+	} catch (error) {
+		log.error(`Error showing task ${id}: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'TASK_OPERATION_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -0,0 +1,174 @@
+/**
+ * update-subtask-by-id.js
+ * Direct function implementation for appending information to a specific subtask
+ */
+
+import { updateSubtaskById } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
+import { createLogWrapper } from '../../tools/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} 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);
+
+	try {
+		logWrapper.info(
+			`Updating subtask by ID via direct function. ID: ${id}, ProjectRoot: ${projectRoot}`
+		);
+
+		// 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
+			};
+		}
+
+		// Basic validation for ID format (e.g., '5.2')
+		if (!id || typeof id !== 'string' || !id.includes('.')) {
+			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);
+			return {
+				success: false,
+				error: { code: 'MISSING_PROMPT', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Validate subtask ID format
+		const subtaskId = 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);
+			return {
+				success: false,
+				error: { code: 'INVALID_SUBTASK_ID_TYPE', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		const subtaskIdStr = String(subtaskId);
+		if (!subtaskIdStr.includes('.')) {
+			const errorMessage = `Invalid subtask ID format: ${subtaskIdStr}. Subtask ID must be in format "parentId.subtaskId" (e.g., "5.2").`;
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'INVALID_SUBTASK_ID_FORMAT', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Use the provided path
+		const tasksPath = tasksJsonPath;
+		const useResearch = research === true;
+
+		log.info(
+			`Updating subtask with ID ${subtaskIdStr} with prompt "${prompt}" and research: ${useResearch}`
+		);
+
+		const wasSilent = isSilentMode();
+		if (!wasSilent) {
+			enableSilentMode();
+		}
+
+		try {
+			// Execute core updateSubtaskById function
+			const updatedSubtask = await updateSubtaskById(
+				tasksPath,
+				subtaskIdStr,
+				prompt,
+				useResearch,
+				{ mcpLog: logWrapper, session, projectRoot },
+				'json'
+			);
+
+			if (updatedSubtask === null) {
+				const message = `Subtask ${id} or its parent task not found.`;
+				logWrapper.error(message); // Log as error since it couldn't be found
+				return {
+					success: false,
+					error: { code: 'SUBTASK_NOT_FOUND', message: message },
+					fromCache: false
+				};
+			}
+
+			// Subtask updated successfully
+			const successMessage = `Successfully updated subtask with ID ${subtaskIdStr}`;
+			logWrapper.success(successMessage);
+			return {
+				success: true,
+				data: {
+					message: `Successfully updated subtask with ID ${subtaskIdStr}`,
+					subtaskId: subtaskIdStr,
+					parentId: subtaskIdStr.split('.')[0],
+					subtask: updatedSubtask,
+					tasksPath,
+					useResearch
+				},
+				fromCache: false
+			};
+		} 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();
+			}
+		}
+	} catch (error) {
+		logWrapper.error(
+			`Setup error in updateSubtaskByIdDirect: ${error.message}`
+		);
+		if (isSilentMode()) disableSilentMode();
+		return {
+			success: false,
+			error: {
+				code: 'DIRECT_FUNCTION_SETUP_ERROR',
+				message: error.message || 'Unknown setup error'
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,180 @@
+/**
+ * update-task-by-id.js
+ * Direct function implementation for updating a single task by ID with new information
+ */
+
+import { updateTaskById } from '../../../../scripts/modules/task-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
+import { createLogWrapper } from '../../tools/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} 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);
+
+	try {
+		logWrapper.info(
+			`Updating task by ID via direct function. ID: ${id}, ProjectRoot: ${projectRoot}`
+		);
+
+		// 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) {
+			const errorMessage =
+				'No task ID specified. Please provide a task ID to update.';
+			logWrapper.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_TASK_ID', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		if (!prompt) {
+			const errorMessage =
+				'No prompt specified. Please provide a prompt with new information for the task update.';
+			logWrapper.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_PROMPT', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Parse taskId - handle both string and number values
+		let taskId;
+		if (typeof id === 'string') {
+			// Handle subtask IDs (e.g., "5.2")
+			if (id.includes('.')) {
+				taskId = id; // Keep as string for subtask IDs
+			} else {
+				// Parse as integer for main task IDs
+				taskId = parseInt(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);
+					return {
+						success: false,
+						error: { code: 'INVALID_TASK_ID', message: errorMessage },
+						fromCache: false
+					};
+				}
+			}
+		} else {
+			taskId = id;
+		}
+
+		// Use the provided path
+		const tasksPath = tasksJsonPath;
+
+		// Get research flag
+		const useResearch = research === true;
+
+		logWrapper.info(
+			`Updating task with ID ${taskId} with prompt "${prompt}" and research: ${useResearch}`
+		);
+
+		const wasSilent = isSilentMode();
+		if (!wasSilent) {
+			enableSilentMode();
+		}
+
+		try {
+			// Execute core updateTaskById function with proper parameters
+			const updatedTask = await updateTaskById(
+				tasksPath,
+				taskId,
+				prompt,
+				useResearch,
+				{
+					mcpLog: logWrapper,
+					session,
+					projectRoot
+				},
+				'json'
+			);
+
+			// Check if the core function indicated the task wasn't updated (e.g., status was 'done')
+			if (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 },
+					fromCache: false
+				};
+			}
+
+			// Task was updated successfully
+			const successMessage = `Successfully updated task with ID ${taskId} based on the prompt`;
+			logWrapper.success(successMessage);
+			return {
+				success: true,
+				data: {
+					message: successMessage,
+					taskId: taskId,
+					tasksPath: tasksPath,
+					useResearch: useResearch,
+					updated: true,
+					updatedTask: updatedTask
+				},
+				fromCache: false
+			};
+		} catch (error) {
+			logWrapper.error(`Error updating task by ID: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'UPDATE_TASK_CORE_ERROR',
+					message: error.message || 'Unknown error updating task'
+				},
+				fromCache: false
+			};
+		} finally {
+			if (!wasSilent && isSilentMode()) {
+				disableSilentMode();
+			}
+		}
+	} catch (error) {
+		logWrapper.error(`Setup error in updateTaskByIdDirect: ${error.message}`);
+		if (isSilentMode()) disableSilentMode();
+		return {
+			success: false,
+			error: {
+				code: 'DIRECT_FUNCTION_SETUP_ERROR',
+				message: error.message || 'Unknown setup error'
+			},
+			fromCache: false
+		};
+	}
+}

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

@@ -0,0 +1,124 @@
+/**
+ * update-tasks.js
+ * Direct function implementation for updating tasks based on new context
+ */
+
+import path from 'path';
+import { updateTasks } from '../../../../scripts/modules/task-manager.js';
+import { createLogWrapper } from '../../tools/utils.js';
+
+/**
+ * Direct function wrapper for updating tasks based on new context.
+ *
+ * @param {Object} args - Command arguments containing projectRoot, from, prompt, research 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;
+
+	// 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'
+		);
+
+		// updateTasks returns { success: true, updatedTasks: [...] } on success
+		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
+				}
+			};
+		} else {
+			// Handle case where core function didn't return expected success structure
+			logWrapper.error(
+				'Core updateTasks function did not return a successful structure.'
+			);
+			return {
+				success: false,
+				error: {
+					code: 'CORE_FUNCTION_ERROR',
+					message:
+						result?.message ||
+						'Core function failed to update tasks or returned unexpected result.'
+				}
+			};
+		}
+	} catch (error) {
+		logWrapper.error(`Error executing core updateTasks: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'UPDATE_TASKS_CORE_ERROR',
+				message: error.message || 'Unknown error updating tasks'
+			}
+		};
+	} finally {
+		disableSilentMode(); // Ensure silent mode is disabled
+	}
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Direct function wrapper for validateDependenciesCommand
+ */
+
+import { validateDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+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 {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}`);
+
+		// Use the provided tasksJsonPath
+		const tasksPath = tasksJsonPath;
+
+		// Verify the file exists
+		if (!fs.existsSync(tasksPath)) {
+			return {
+				success: false,
+				error: {
+					code: 'FILE_NOT_FOUND',
+					message: `Tasks file not found at ${tasksPath}`
+				}
+			};
+		}
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+
+		// Call the original command function using the provided tasksPath
+		await validateDependenciesCommand(tasksPath);
+
+		// Restore normal logging
+		disableSilentMode();
+
+		return {
+			success: true,
+			data: {
+				message: 'Dependencies validated successfully',
+				tasksPath
+			}
+		};
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error validating dependencies: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'VALIDATION_ERROR',
+				message: error.message
+			}
+		};
+	}
+}

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

@@ -1,167 +1,93 @@
 /**
  * task-master-core.js
- * Direct function imports from Task Master modules
- * 
- * This module provides direct access to Task Master core functions
- * for improved performance and error handling compared to CLI execution.
+ * Central module that imports and re-exports all direct function implementations
+ * for improved organization and maintainability.
  */
 
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-import fs from 'fs';
+// Import direct function implementations
+import { listTasksDirect } from './direct-functions/list-tasks.js';
+import { getCacheStatsDirect } from './direct-functions/cache-stats.js';
+import { parsePRDDirect } from './direct-functions/parse-prd.js';
+import { updateTasksDirect } from './direct-functions/update-tasks.js';
+import { updateTaskByIdDirect } from './direct-functions/update-task-by-id.js';
+import { updateSubtaskByIdDirect } from './direct-functions/update-subtask-by-id.js';
+import { generateTaskFilesDirect } from './direct-functions/generate-task-files.js';
+import { setTaskStatusDirect } from './direct-functions/set-task-status.js';
+import { showTaskDirect } from './direct-functions/show-task.js';
+import { nextTaskDirect } from './direct-functions/next-task.js';
+import { expandTaskDirect } from './direct-functions/expand-task.js';
+import { addTaskDirect } from './direct-functions/add-task.js';
+import { addSubtaskDirect } from './direct-functions/add-subtask.js';
+import { removeSubtaskDirect } from './direct-functions/remove-subtask.js';
+import { analyzeTaskComplexityDirect } from './direct-functions/analyze-task-complexity.js';
+import { clearSubtasksDirect } from './direct-functions/clear-subtasks.js';
+import { expandAllTasksDirect } from './direct-functions/expand-all-tasks.js';
+import { removeDependencyDirect } from './direct-functions/remove-dependency.js';
+import { validateDependenciesDirect } from './direct-functions/validate-dependencies.js';
+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';
 
-// Get the current module's directory
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+// Re-export utility functions
+export { findTasksJsonPath } from './utils/path-utils.js';
 
-// Import Task Master modules
-import { 
-  listTasks,
-  // We'll import more functions as we continue implementation
-} from '../../../scripts/modules/task-manager.js';
+// Use Map for potential future enhancements like introspection or dynamic dispatch
+export const directFunctions = new Map([
+	['listTasksDirect', listTasksDirect],
+	['getCacheStatsDirect', getCacheStatsDirect],
+	['parsePRDDirect', parsePRDDirect],
+	['updateTasksDirect', updateTasksDirect],
+	['updateTaskByIdDirect', updateTaskByIdDirect],
+	['updateSubtaskByIdDirect', updateSubtaskByIdDirect],
+	['generateTaskFilesDirect', generateTaskFilesDirect],
+	['setTaskStatusDirect', setTaskStatusDirect],
+	['showTaskDirect', showTaskDirect],
+	['nextTaskDirect', nextTaskDirect],
+	['expandTaskDirect', expandTaskDirect],
+	['addTaskDirect', addTaskDirect],
+	['addSubtaskDirect', addSubtaskDirect],
+	['removeSubtaskDirect', removeSubtaskDirect],
+	['analyzeTaskComplexityDirect', analyzeTaskComplexityDirect],
+	['clearSubtasksDirect', clearSubtasksDirect],
+	['expandAllTasksDirect', expandAllTasksDirect],
+	['removeDependencyDirect', removeDependencyDirect],
+	['validateDependenciesDirect', validateDependenciesDirect],
+	['fixDependenciesDirect', fixDependenciesDirect],
+	['complexityReportDirect', complexityReportDirect],
+	['addDependencyDirect', addDependencyDirect],
+	['removeTaskDirect', removeTaskDirect],
+	['initializeProjectDirect', initializeProjectDirect],
+	['modelsDirect', modelsDirect]
+]);
 
-// Import context manager
-import { contextManager } from './context-manager.js';
-import { getCachedOrExecute } from '../tools/utils.js'; // Import the utility here
-
-/**
- * Finds the absolute path to the tasks.json file based on project root and arguments.
- * @param {Object} args - Command arguments, potentially including 'projectRoot' and 'file'.
- * @param {Object} log - Logger object.
- * @returns {string} - Absolute path to the tasks.json file.
- * @throws {Error} - If tasks.json cannot be found.
- */
-function findTasksJsonPath(args, log) {
-  // Assume projectRoot is already normalized absolute path if passed in args
-  // Or use getProjectRoot if we decide to centralize that logic
-  const projectRoot = args.projectRoot || process.cwd(); 
-  log.info(`Searching for tasks.json within project root: ${projectRoot}`);
-
-  const possiblePaths = [];
-
-  // 1. If a file is explicitly provided relative to projectRoot
-  if (args.file) {
-    possiblePaths.push(path.resolve(projectRoot, args.file));
-  }
-
-  // 2. Check the standard locations relative to projectRoot
-  possiblePaths.push(
-    path.join(projectRoot, 'tasks.json'),
-    path.join(projectRoot, 'tasks', 'tasks.json')
-  );
-
-  log.info(`Checking potential task file paths: ${possiblePaths.join(', ')}`);
-
-  // Find the first existing path
-  for (const p of possiblePaths) {
-    if (fs.existsSync(p)) {
-      log.info(`Found tasks file at: ${p}`);
-      return p;
-    }
-  }
-
-  // If no file was found, throw an error
-  const error = new Error(`Tasks file not found in any of the expected locations relative to ${projectRoot}: ${possiblePaths.join(', ')}`);
-  error.code = 'TASKS_FILE_NOT_FOUND';
-  throw error;
-}
-
-/**
- * Direct function wrapper for listTasks with error handling and caching.
- *
- * @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) {
-  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: 'FIND_TASKS_PATH_ERROR', message: error.message }, fromCache: 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 () => {
-    try {
-      log.info(`Executing core listTasks function for path: ${tasksPath}, filter: ${statusFilter}, subtasks: ${withSubtasks}`);
-      const resultData = listTasks(tasksPath, statusFilter, withSubtasks, 'json');
-
-      if (!resultData || !resultData.tasks) {
-        log.error('Invalid or empty response from listTasks core function');
-        return { success: false, error: { code: 'INVALID_CORE_RESPONSE', message: 'Invalid or empty response from listTasks core function' } };
-      }
-      log.info(`Core listTasks function retrieved ${resultData.tasks.length} tasks`);
-      return { success: true, data: resultData };
-
-    } catch (error) {
-      log.error(`Core listTasks function failed: ${error.message}`);
-      return { success: false, error: { code: 'LIST_TASKS_CORE_ERROR', message: error.message || 'Failed to list tasks' } };
-    }
-  };
-
-  // Use the caching utility
-  try {
-      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) {
-      // 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: 'CACHE_UTIL_ERROR', message: error.message }, fromCache: false };
-  }
-}
-
-/**
- * Get cache statistics for monitoring
- * @param {Object} args - Command arguments
- * @param {Object} log - Logger object
- * @returns {Object} - Cache statistics
- */
-export async function getCacheStatsDirect(args, log) {
-  try {
-    log.info('Retrieving cache statistics');
-    const stats = contextManager.getStats();
-    return {
-      success: true,
-      data: stats
-    };
-  } catch (error) {
-    log.error(`Error getting cache stats: ${error.message}`);
-    return {
-      success: false,
-      error: {
-        code: 'CACHE_STATS_ERROR',
-        message: error.message || 'Unknown error occurred'
-      }
-    };
-  }
-}
-
-/**
- * Maps Task Master functions to their direct implementation
- */
-export const directFunctions = {
-  list: listTasksDirect,
-  cacheStats: getCacheStatsDirect,
-  // Add more functions as we implement them
+// Re-export all direct function implementations
+export {
+	listTasksDirect,
+	getCacheStatsDirect,
+	parsePRDDirect,
+	updateTasksDirect,
+	updateTaskByIdDirect,
+	updateSubtaskByIdDirect,
+	generateTaskFilesDirect,
+	setTaskStatusDirect,
+	showTaskDirect,
+	nextTaskDirect,
+	expandTaskDirect,
+	addTaskDirect,
+	addSubtaskDirect,
+	removeSubtaskDirect,
+	analyzeTaskComplexityDirect,
+	clearSubtasksDirect,
+	expandAllTasksDirect,
+	removeDependencyDirect,
+	validateDependenciesDirect,
+	fixDependenciesDirect,
+	complexityReportDirect,
+	addDependencyDirect,
+	removeTaskDirect,
+	initializeProjectDirect,
+	modelsDirect
 };

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

@@ -0,0 +1,47 @@
+/**
+ * Temporarily sets environment variables from session.env, executes an action,
+ * and restores the original environment variables.
+ * @param {object | undefined} sessionEnv - The environment object from the session.
+ * @param {Function} actionFn - An async function to execute with the temporary environment.
+ * @returns {Promise<any>} The result of the actionFn.
+ */
+export async function withSessionEnv(sessionEnv, actionFn) {
+	if (
+		!sessionEnv ||
+		typeof sessionEnv !== 'object' ||
+		Object.keys(sessionEnv).length === 0
+	) {
+		// If no sessionEnv is provided, just run the action directly
+		return await actionFn();
+	}
+
+	const originalEnv = {};
+	const keysToRestore = [];
+
+	// Set environment variables from sessionEnv
+	for (const key in sessionEnv) {
+		if (Object.prototype.hasOwnProperty.call(sessionEnv, key)) {
+			// Store original value if it exists, otherwise mark for deletion
+			if (process.env[key] !== undefined) {
+				originalEnv[key] = process.env[key];
+			}
+			keysToRestore.push(key);
+			process.env[key] = sessionEnv[key];
+		}
+	}
+
+	try {
+		// Execute the provided action function
+		return await actionFn();
+	} finally {
+		// Restore original environment variables
+		for (const key of keysToRestore) {
+			if (Object.prototype.hasOwnProperty.call(originalEnv, key)) {
+				process.env[key] = originalEnv[key];
+			} else {
+				// If the key didn't exist originally, delete it
+				delete process.env[key];
+			}
+		}
+	}
+}

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

@@ -0,0 +1,393 @@
+/**
+ * path-utils.js
+ * Utility functions for file path operations in Task Master
+ *
+ * This module provides robust path resolution for both:
+ * 1. PACKAGE PATH: Where task-master code is installed
+ *    (global node_modules OR local ./node_modules/task-master OR direct from repo)
+ * 2. PROJECT PATH: Where user's tasks.json resides (typically user's project root)
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import os from 'os';
+
+// Store last found project root to improve performance on subsequent calls (primarily for CLI)
+export let lastFoundProjectRoot = null;
+
+// Project marker files that indicate a potential project root
+export const PROJECT_MARKERS = [
+	// Task Master specific
+	'tasks.json',
+	'tasks/tasks.json',
+
+	// Common version control
+	'.git',
+	'.svn',
+
+	// Common package files
+	'package.json',
+	'pyproject.toml',
+	'Gemfile',
+	'go.mod',
+	'Cargo.toml',
+
+	// Common IDE/editor folders
+	'.cursor',
+	'.vscode',
+	'.idea',
+
+	// Common dependency directories (check if directory)
+	'node_modules',
+	'venv',
+	'.venv',
+
+	// Common config files
+	'.env',
+	'.eslintrc',
+	'tsconfig.json',
+	'babel.config.js',
+	'jest.config.js',
+	'webpack.config.js',
+
+	// Common CI/CD files
+	'.github/workflows',
+	'.gitlab-ci.yml',
+	'.circleci/config.yml'
+];
+
+/**
+ * Gets the path to the task-master package installation directory
+ * NOTE: This might become unnecessary if CLI fallback in MCP utils is removed.
+ * @returns {string} - Absolute path to the package installation directory
+ */
+export function getPackagePath() {
+	// When running from source, __dirname is the directory containing this file
+	// When running from npm, we need to find the package root
+	const thisFilePath = fileURLToPath(import.meta.url);
+	const thisFileDir = path.dirname(thisFilePath);
+
+	// Navigate from core/utils up to the package root
+	// In dev: /path/to/task-master/mcp-server/src/core/utils -> /path/to/task-master
+	// In npm: /path/to/node_modules/task-master/mcp-server/src/core/utils -> /path/to/node_modules/task-master
+	return path.resolve(thisFileDir, '../../../../');
+}
+
+/**
+ * Finds the absolute path to the tasks.json file based on project root and arguments.
+ * @param {Object} args - Command arguments, potentially including 'projectRoot' and 'file'.
+ * @param {Object} log - Logger object.
+ * @returns {string} - Absolute path to the tasks.json file.
+ * @throws {Error} - If tasks.json cannot be found.
+ */
+export function findTasksJsonPath(args, log) {
+	// PRECEDENCE ORDER for finding tasks.json:
+	// 1. Explicitly provided `projectRoot` in args (Highest priority, expected in MCP context)
+	// 2. Previously found/cached `lastFoundProjectRoot` (primarily for CLI performance)
+	// 3. Search upwards from current working directory (`process.cwd()`) - CLI usage
+
+	// 1. If project root is explicitly provided (e.g., from MCP session), use it directly
+	if (args.projectRoot) {
+		const projectRoot = args.projectRoot;
+		log.info(`Using explicitly provided project root: ${projectRoot}`);
+		try {
+			// This will throw if tasks.json isn't found within this root
+			return findTasksJsonInDirectory(projectRoot, args.file, log);
+		} catch (error) {
+			// Include debug info in error
+			const debugInfo = {
+				projectRoot,
+				currentDir: process.cwd(),
+				serverDir: path.dirname(process.argv[1]),
+				possibleProjectRoot: path.resolve(
+					path.dirname(process.argv[1]),
+					'../..'
+				),
+				lastFoundProjectRoot,
+				searchedPaths: error.message
+			};
+
+			error.message = `Tasks file not found in any of the expected locations relative to project root "${projectRoot}" (from session).\nDebug Info: ${JSON.stringify(debugInfo, null, 2)}`;
+			throw error;
+		}
+	}
+
+	// --- Fallback logic primarily for CLI or when projectRoot isn't passed ---
+
+	// 2. If we have a last known project root that worked, try it first
+	if (lastFoundProjectRoot) {
+		log.info(`Trying last known project root: ${lastFoundProjectRoot}`);
+		try {
+			// Use the cached root
+			const tasksPath = findTasksJsonInDirectory(
+				lastFoundProjectRoot,
+				args.file,
+				log
+			);
+			return tasksPath; // Return if found in cached root
+		} catch (error) {
+			log.info(
+				`Task file not found in last known project root, continuing search.`
+			);
+			// Continue with search if not found in cache
+		}
+	}
+
+	// 3. Start search from current directory (most common CLI scenario)
+	const startDir = process.cwd();
+	log.info(
+		`Searching for tasks.json starting from current directory: ${startDir}`
+	);
+
+	// Try to find tasks.json by walking up the directory tree from cwd
+	try {
+		// This will throw if not found in the CWD tree
+		return findTasksJsonWithParentSearch(startDir, args.file, log);
+	} catch (error) {
+		// If all attempts fail, augment and throw the original error from CWD search
+		error.message = `${error.message}\n\nPossible solutions:\n1. Run the command from your project directory containing tasks.json\n2. Use --project-root=/path/to/project to specify the project location (if using CLI)\n3. Ensure the project root is correctly passed from the client (if using MCP)\n\nCurrent working directory: ${startDir}\nLast known project root: ${lastFoundProjectRoot}\nProject root from args: ${args.projectRoot}`;
+		throw error;
+	}
+}
+
+/**
+ * Check if a directory contains any project marker files or directories
+ * @param {string} dirPath - Directory to check
+ * @returns {boolean} - True if the directory contains any project markers
+ */
+function hasProjectMarkers(dirPath) {
+	return PROJECT_MARKERS.some((marker) => {
+		const markerPath = path.join(dirPath, marker);
+		// Check if the marker exists as either a file or directory
+		return fs.existsSync(markerPath);
+	});
+}
+
+/**
+ * Search for tasks.json in a specific directory
+ * @param {string} dirPath - Directory to search in
+ * @param {string} explicitFilePath - Optional explicit file path relative to dirPath
+ * @param {Object} log - Logger object
+ * @returns {string} - Absolute path to tasks.json
+ * @throws {Error} - If tasks.json cannot be found
+ */
+function findTasksJsonInDirectory(dirPath, explicitFilePath, log) {
+	const possiblePaths = [];
+
+	// 1. If a file is explicitly provided relative to dirPath
+	if (explicitFilePath) {
+		possiblePaths.push(path.resolve(dirPath, explicitFilePath));
+	}
+
+	// 2. Check the standard locations relative to dirPath
+	possiblePaths.push(
+		path.join(dirPath, 'tasks.json'),
+		path.join(dirPath, 'tasks', 'tasks.json')
+	);
+
+	log.info(`Checking potential task file paths: ${possiblePaths.join(', ')}`);
+
+	// Find the first existing path
+	for (const p of possiblePaths) {
+		log.info(`Checking if exists: ${p}`);
+		const exists = fs.existsSync(p);
+		log.info(`Path ${p} exists: ${exists}`);
+
+		if (exists) {
+			log.info(`Found tasks file at: ${p}`);
+			// Store the project root for future use
+			lastFoundProjectRoot = dirPath;
+			return p;
+		}
+	}
+
+	// If no file was found, throw an error
+	const error = new Error(
+		`Tasks file not found in any of the expected locations relative to ${dirPath}: ${possiblePaths.join(', ')}`
+	);
+	error.code = 'TASKS_FILE_NOT_FOUND';
+	throw error;
+}
+
+/**
+ * Recursively search for tasks.json in the given directory and parent directories
+ * Also looks for project markers to identify potential project roots
+ * @param {string} startDir - Directory to start searching from
+ * @param {string} explicitFilePath - Optional explicit file path
+ * @param {Object} log - Logger object
+ * @returns {string} - Absolute path to tasks.json
+ * @throws {Error} - If tasks.json cannot be found in any parent directory
+ */
+function findTasksJsonWithParentSearch(startDir, explicitFilePath, log) {
+	let currentDir = startDir;
+	const rootDir = path.parse(currentDir).root;
+
+	// Keep traversing up until we hit the root directory
+	while (currentDir !== rootDir) {
+		// First check for tasks.json directly
+		try {
+			return findTasksJsonInDirectory(currentDir, explicitFilePath, log);
+		} catch (error) {
+			// If tasks.json not found but the directory has project markers,
+			// log it as a potential project root (helpful for debugging)
+			if (hasProjectMarkers(currentDir)) {
+				log.info(`Found project markers in ${currentDir}, but no tasks.json`);
+			}
+
+			// Move up to parent directory
+			const parentDir = path.dirname(currentDir);
+
+			// Check if we've reached the root
+			if (parentDir === currentDir) {
+				break;
+			}
+
+			log.info(
+				`Tasks file not found in ${currentDir}, searching in parent directory: ${parentDir}`
+			);
+			currentDir = parentDir;
+		}
+	}
+
+	// If we've searched all the way to the root and found nothing
+	const error = new Error(
+		`Tasks file not found in ${startDir} or any parent directory.`
+	);
+	error.code = 'TASKS_FILE_NOT_FOUND';
+	throw error;
+}
+
+// Note: findTasksWithNpmConsideration is not used by findTasksJsonPath and might be legacy or used elsewhere.
+// If confirmed unused, it could potentially be removed in a separate cleanup.
+function findTasksWithNpmConsideration(startDir, log) {
+	// First try our recursive parent search from cwd
+	try {
+		return findTasksJsonWithParentSearch(startDir, null, log);
+	} catch (error) {
+		// If that fails, try looking relative to the executable location
+		const execPath = process.argv[1];
+		const execDir = path.dirname(execPath);
+		log.info(`Looking for tasks file relative to executable at: ${execDir}`);
+
+		try {
+			return findTasksJsonWithParentSearch(execDir, null, log);
+		} catch (secondError) {
+			// If that also fails, check standard locations in user's home directory
+			const homeDir = os.homedir();
+			log.info(`Looking for tasks file in home directory: ${homeDir}`);
+
+			try {
+				// Check standard locations in home dir
+				return findTasksJsonInDirectory(
+					path.join(homeDir, '.task-master'),
+					null,
+					log
+				);
+			} catch (thirdError) {
+				// If all approaches fail, throw the original error
+				throw error;
+			}
+		}
+	}
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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

@@ -1,10 +1,10 @@
-import { FastMCP } from "fastmcp";
-import path from "path";
-import dotenv from "dotenv";
-import { fileURLToPath } from "url";
-import fs from "fs";
-import logger from "./logger.js";
-import { registerTaskMasterTools } from "./tools/index.js";
+import { FastMCP } from 'fastmcp';
+import path from 'path';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import logger from './logger.js';
+import { registerTaskMasterTools } from './tools/index.js';
 
 // Load environment variables
 dotenv.config();
@@ -19,20 +19,20 @@ const __dirname = path.dirname(__filename);
 class TaskMasterMCPServer {
 	constructor() {
 		// Get version from package.json using synchronous fs
-    const packagePath = path.join(__dirname, "../../package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+		const packagePath = path.join(__dirname, '../../package.json');
+		const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
 
 		this.options = {
-      name: "Task Master MCP Server",
-      version: packageJson.version,
+			name: 'Task Master MCP Server',
+			version: packageJson.version
 		};
 
 		this.server = new FastMCP(this.options);
 		this.initialized = false;
 
-    // this.server.addResource({});
+		this.server.addResource({});
 
-    // this.server.addResourceTemplate({});
+		this.server.addResourceTemplate({});
 
 		// Bind methods
 		this.init = this.init.bind(this);
@@ -49,8 +49,8 @@ class TaskMasterMCPServer {
 	async init() {
 		if (this.initialized) return;
 
-    // Register Task Master tools
-    registerTaskMasterTools(this.server);
+		// Pass the manager instance to the tool registration function
+		registerTaskMasterTools(this.server, this.asyncManager);
 
 		this.initialized = true;
 
@@ -65,9 +65,10 @@ class TaskMasterMCPServer {
 			await this.init();
 		}
 
-    // Start the FastMCP server
+		// Start the FastMCP server with increased timeout
 		await this.server.start({
-      transportType: "stdio",
+			transportType: 'stdio',
+			timeout: 120000 // 2 minutes timeout (in milliseconds)
 		});
 
 		return this;

mcp-server/src/logger.js

@@ -1,4 +1,6 @@
-import chalk from "chalk";
+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 = {
@@ -6,13 +8,11 @@ const LOG_LEVELS = {
 	info: 1,
 	warn: 2,
 	error: 3,
-  success: 4,
+	success: 4
 };
 
-// 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;
+// Get log level from config manager or default to info
+const LOG_LEVEL = LOG_LEVELS[getLogLevel().toLowerCase()] ?? LOG_LEVELS.info;
 
 /**
  * Logs a message with the specified level
@@ -20,44 +20,85 @@ const LOG_LEVEL = process.env.LOG_LEVEL
  * @param  {...any} args - Arguments to log
  */
 function log(level, ...args) {
-  const icons = {
-    debug: chalk.gray("🔍"),
-    info: chalk.blue("ℹ️"),
-    warn: chalk.yellow("⚠️"),
-    error: chalk.red("❌"),
-    success: chalk.green("✅"),
+	// Skip logging if silent mode is enabled
+	if (isSilentMode()) {
+		return;
+	}
+
+	// Use text prefixes instead of emojis
+	const prefixes = {
+		debug: chalk.gray('[DEBUG]'),
+		info: chalk.blue('[INFO]'),
+		warn: chalk.yellow('[WARN]'),
+		error: chalk.red('[ERROR]'),
+		success: chalk.green('[SUCCESS]')
 	};
 
-  if (LOG_LEVELS[level] >= LOG_LEVEL) {
-    const icon = icons[level] || "";
+	if (LOG_LEVELS[level] !== undefined && LOG_LEVELS[level] >= LOG_LEVEL) {
+		const prefix = prefixes[level] || '';
+		let coloredArgs = args;
 
-    if (level === "error") {
-      console.error(icon, chalk.red(...args));
-    } else if (level === "warn") {
-      console.warn(icon, chalk.yellow(...args));
-    } else if (level === "success") {
-      console.log(icon, chalk.green(...args));
-    } else if (level === "info") {
-      console.log(icon, chalk.blue(...args));
-    } else {
-      console.log(icon, ...args);
+		try {
+			switch (level) {
+				case 'error':
+					coloredArgs = args.map((arg) =>
+						typeof arg === 'string' ? chalk.red(arg) : arg
+					);
+					break;
+				case 'warn':
+					coloredArgs = args.map((arg) =>
+						typeof arg === 'string' ? chalk.yellow(arg) : arg
+					);
+					break;
+				case 'success':
+					coloredArgs = args.map((arg) =>
+						typeof arg === 'string' ? chalk.green(arg) : arg
+					);
+					break;
+				case 'info':
+					coloredArgs = args.map((arg) =>
+						typeof arg === 'string' ? chalk.blue(arg) : arg
+					);
+					break;
+				case 'debug':
+					coloredArgs = args.map((arg) =>
+						typeof arg === 'string' ? chalk.gray(arg) : arg
+					);
+					break;
+				// default: use original args (no color)
 			}
+		} catch (colorError) {
+			// Fallback if chalk fails on an argument
+			// Use console.error here for internal logger errors, separate from normal logging
+			console.error('Internal Logger Error applying chalk color:', colorError);
+			coloredArgs = args;
+		}
+
+		// Revert to console.log - FastMCP's context logger (context.log)
+		// is responsible for directing logs correctly (e.g., to stderr)
+		// during tool execution without upsetting the client connection.
+		// Logs outside of tool execution (like startup) will go to stdout.
+		console.log(prefix, ...coloredArgs);
 	}
 }
 
 /**
  * Create a logger object with methods for different log levels
- * Can be used as a drop-in replacement for existing logger initialization
  * @returns {Object} Logger object with info, error, debug, warn, and success methods
  */
 export function createLogger() {
+	const createLogMethod =
+		(level) =>
+		(...args) =>
+			log(level, ...args);
+
 	return {
-    debug: (message) => log("debug", message),
-    info: (message) => log("info", message),
-    warn: (message) => log("warn", message),
-    error: (message) => log("error", message),
-    success: (message) => log("success", message),
-    log: log, // Also expose the raw log function
+		debug: createLogMethod('debug'),
+		info: createLogMethod('info'),
+		warn: createLogMethod('warn'),
+		error: createLogMethod('error'),
+		success: createLogMethod('success'),
+		log: log // Also expose the raw log function
 	};
 }
 

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

@@ -1 +0,0 @@
- 

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

@@ -0,0 +1,86 @@
+/**
+ * tools/add-dependency.js
+ * Tool for adding a dependency to a task
+ */
+
+import { z } from 'zod';
+import {
+	handleApiResult,
+	createErrorResponse,
+	getProjectRootFromSession,
+	withNormalizedProjectRoot
+} 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
+ * @param {Object} server - FastMCP server instance
+ */
+export function registerAddDependencyTool(server) {
+	server.addTool({
+		name: 'add_dependency',
+		description: 'Add a dependency relationship between two tasks',
+		parameters: z.object({
+			id: z.string().describe('ID of task that will depend on another task'),
+			dependsOn: z
+				.string()
+				.describe('ID of task that will become a dependency'),
+			file: z
+				.string()
+				.optional()
+				.describe(
+					'Absolute path to the tasks file (default: tasks/tasks.json)'
+				),
+			projectRoot: z
+				.string()
+				.describe('The directory of the project. Must be an absolute path.')
+		}),
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+			try {
+				log.info(
+					`Adding dependency for task ${args.id} to depend on ${args.dependsOn}`
+				);
+
+				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}`
+					);
+				}
+
+				// Call the direct function with the resolved path
+				const result = await addDependencyDirect(
+					{
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						dependsOn: args.dependsOn
+					},
+					log
+					// Remove context object
+				);
+
+				// Log result
+				if (result.success) {
+					log.info(`Successfully added dependency: ${result.data.message}`);
+				} else {
+					log.error(`Failed to add dependency: ${result.error.message}`);
+				}
+
+				// Use handleApiResult to format the response
+				return handleApiResult(result, log, 'Error adding dependency');
+			} catch (error) {
+				log.error(`Error in addDependency tool: ${error.message}`);
+				return createErrorResponse(error.message);
+			}
+		})
+	});
+}

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

@@ -0,0 +1,109 @@
+/**
+ * tools/add-subtask.js
+ * Tool for adding subtasks to existing tasks
+ */
+
+import { z } from 'zod';
+import {
+	handleApiResult,
+	createErrorResponse,
+	withNormalizedProjectRoot
+} 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
+ * @param {Object} server - FastMCP server instance
+ */
+export function registerAddSubtaskTool(server) {
+	server.addTool({
+		name: 'add_subtask',
+		description: 'Add a subtask to an existing task',
+		parameters: z.object({
+			id: z.string().describe('Parent task ID (required)'),
+			taskId: z
+				.string()
+				.optional()
+				.describe('Existing task ID to convert to subtask'),
+			title: z
+				.string()
+				.optional()
+				.describe('Title for the new subtask (when creating a new subtask)'),
+			description: z
+				.string()
+				.optional()
+				.describe('Description for the new subtask'),
+			details: z
+				.string()
+				.optional()
+				.describe('Implementation details for the new subtask'),
+			status: z
+				.string()
+				.optional()
+				.describe("Status for the new subtask (default: 'pending')"),
+			dependencies: z
+				.string()
+				.optional()
+				.describe('Comma-separated list of dependency IDs for the new subtask'),
+			file: z
+				.string()
+				.optional()
+				.describe(
+					'Absolute 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.')
+		}),
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+			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}`
+					);
+				}
+
+				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
+					},
+					log
+				);
+
+				if (result.success) {
+					log.info(`Subtask added successfully: ${result.data.message}`);
+				} else {
+					log.error(`Failed to add subtask: ${result.error.message}`);
+				}
+
+				return handleApiResult(result, log, 'Error adding subtask');
+			} catch (error) {
+				log.error(`Error in addSubtask tool: ${error.message}`);
+				return createErrorResponse(error.message);
+			}
+		})
+	});
+}

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

@@ -0,0 +1,109 @@
+/**
+ * tools/add-task.js
+ * Tool to add a new task using AI
+ */
+
+import { z } from 'zod';
+import {
+	createErrorResponse,
+	handleApiResult,
+	withNormalizedProjectRoot
+} 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
+ * @param {Object} server - FastMCP server instance
+ */
+export function registerAddTaskTool(server) {
+	server.addTool({
+		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)'),
+			dependencies: z
+				.string()
+				.optional()
+				.describe('Comma-separated list of task IDs this task depends on'),
+			priority: z
+				.string()
+				.optional()
+				.describe('Task priority (high, medium, low)'),
+			file: z
+				.string()
+				.optional()
+				.describe('Path to the tasks file (default: tasks/tasks.json)'),
+			projectRoot: z
+				.string()
+				.describe('The directory of the project. Must be an absolute path.'),
+			research: z
+				.boolean()
+				.optional()
+				.describe('Whether to use research capabilities for task creation')
+		}),
+		execute: withNormalizedProjectRoot(async (args, { log, 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}`
+					);
+				}
+
+				// Call the direct functionP
+				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
+					},
+					log,
+					{ session }
+				);
+
+				return handleApiResult(result, log);
+			} catch (error) {
+				log.error(`Error in add-task tool: ${error.message}`);
+				return createErrorResponse(error.message);
+			}
+		})
+	});
+}

mcp-server/src/tools/addTask.js

@@ -1,66 +0,0 @@
-/**
- * tools/addTask.js
- * Tool to add a new task using AI
- */
-
-import { z } from "zod";
-import {
-  executeTaskMasterCommand,
-  createContentResponse,
-  createErrorResponse,
-} from "./utils.js";
-
-/**
- * Register the addTask tool with the MCP server
- * @param {FastMCP} server - FastMCP server instance
- */
-export function registerAddTaskTool(server) {
-  server.addTool({
-    name: "addTask",
-    description: "Add a new task using AI",
-    parameters: z.object({
-      prompt: z.string().describe("Description of the task to add"),
-      dependencies: z
-        .string()
-        .optional()
-        .describe("Comma-separated list of task IDs this task depends on"),
-      priority: z
-        .string()
-        .optional()
-        .describe("Task priority (high, medium, low)"),
-      file: z.string().optional().describe("Path to the tasks file"),
-      projectRoot: z
-        .string()
-        .describe(
-          "Root directory of the project (default: current working directory)"
-        ),
-    }),
-    execute: async (args, { log }) => {
-      try {
-        log.info(`Adding new task: ${args.prompt}`);
-
-        const cmdArgs = [`--prompt="${args.prompt}"`];
-        if (args.dependencies)
-          cmdArgs.push(`--dependencies=${args.dependencies}`);
-        if (args.priority) cmdArgs.push(`--priority=${args.priority}`);
-        if (args.file) cmdArgs.push(`--file=${args.file}`);
-
-        const result = executeTaskMasterCommand(
-          "add-task",
-          log,
-          cmdArgs,
-          projectRoot
-        );
-
-        if (!result.success) {
-          throw new Error(result.error);
-        }
-
-        return createContentResponse(result.stdout);
-      } catch (error) {
-        log.error(`Error adding task: ${error.message}`);
-        return createErrorResponse(`Error adding task: ${error.message}`);
-      }
-    },
-  });
-}

mcp-server/src/tools/analyze.js

@@ -0,0 +1,131 @@
+/**
+ * tools/analyze.js
+ * Tool for analyzing task complexity and generating recommendations
+ */
+
+import { z } from 'zod';
+import path from 'path';
+import fs from 'fs'; // Import fs for directory check/creation
+import {
+	handleApiResult,
+	createErrorResponse,
+	withNormalizedProjectRoot
+} 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';
+
+/**
+ * Register the analyze_project_complexity tool
+ * @param {Object} server - FastMCP server instance
+ */
+export function registerAnalyzeProjectComplexityTool(server) {
+	server.addTool({
+		name: 'analyze_project_complexity',
+		description:
+			'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).'
+				),
+			file: z
+				.string()
+				.optional()
+				.describe(
+					'Path to the tasks file relative to project root (default: tasks/tasks.json).'
+				),
+			projectRoot: z
+				.string()
+				.describe('The directory of the project. Must be an absolute path.')
+		}),
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+			const toolName = 'analyze_project_complexity'; // Define tool name for logging
+			try {
+				log.info(
+					`Executing ${toolName} tool 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}`
+					);
+				}
+
+				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
+					},
+					log,
+					{ session }
+				);
+
+				// 4. Handle Result
+				log.info(
+					`${toolName}: Direct function result: success=${result.success}`
+				);
+				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}`
+				);
+			}
+		})
+	});
+}