chore: cleanup

* fix: remove cache from list-tasks and next-task mcp calls

* chore: remove cached function

* chore: add changeset

.changeset/beige-doodles-type.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Resolve all issues related to MCP

.changeset/beige-rats-accept.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-- Add support for Google Gemini models via Vercel AI SDK integration.

.changeset/blue-spies-kick.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Add xAI provider and Grok models support

.changeset/cuddly-zebras-matter.md

@@ -1,8 +0,0 @@
----
-'task-master-ai': minor
----
-
-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.

.changeset/easy-toys-wash.md

@@ -1,7 +0,0 @@
----
-'task-master-ai': minor
----
-
-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.
-

.changeset/fine-signs-add.md

@@ -1,13 +0,0 @@
----
-'task-master-ai': patch
----
-
-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.

.changeset/floppy-plants-marry.md

@@ -0,0 +1,9 @@
+---
+'task-master-ai': patch
+---
+
+Fix CLI --force flag for parse-prd command
+
+Previously, the --force flag was not respected when running `parse-prd`, causing the command to prompt for confirmation or fail even when --force was provided. This patch ensures that the flag is correctly passed and handled, allowing users to overwrite existing tasks.json files as intended.
+
+- Fixes #477

.changeset/forty-plums-stay.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': minor
+---
+
+.taskmasterconfig now supports a baseUrl field per model role (main, research, fallback), allowing endpoint overrides for any provider.

.changeset/gentle-views-jump.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Fixes an issue with add-task which did not use the manually defined properties and still needlessly hit the AI endpoint.

.changeset/many-wasps-sell.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Task Master no longer tells you to update when you're already up to date

.changeset/mighty-mirrors-watch.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': minor
----
-
-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."

.changeset/neat-donkeys-shave.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Fixes an issue that prevented remove-subtask with comma separated tasks/subtasks from being deleted (only the first ID was being deleted). Closes #140

.changeset/nine-rocks-sink.md

@@ -1,10 +0,0 @@
----
-'task-master-ai': patch
----
-
-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.

.changeset/ninety-ghosts-relax.md

@@ -1,11 +0,0 @@
----
-'task-master-ai': minor
----
-
-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.

.changeset/ninety-wombats-pull.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Add `--status` flag to `show` command to filter displayed subtasks.

.changeset/pre.json

@@ -0,0 +1,12 @@
+{
+  "mode": "exit",
+  "tag": "rc",
+  "initialVersions": {
+    "task-master-ai": "0.13.2"
+  },
+  "changesets": [
+    "beige-doodles-type",
+    "red-oranges-attend",
+    "red-suns-wash"
+  ]
+}

.changeset/public-cooks-fetch.md

@@ -1,7 +0,0 @@
----
-'task-master-ai': minor
----
-
-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.

.changeset/red-oranges-attend.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Fix ERR_MODULE_NOT_FOUND when trying to run MCP Server

.changeset/red-suns-wash.md

@@ -2,4 +2,4 @@
 'task-master-ai': patch
 ---
 
-Add integration for Roo Code
+Add src directory to exports

.changeset/sharp-dingos-melt.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Fix the error handling of task status settings

.changeset/six-cloths-happen.md

@@ -0,0 +1,7 @@
+---
+'task-master-ai': patch
+---
+
+Remove caching layer from MCP direct functions for task listing, next task, and complexity report
+
+- Fixes issues users where having where they were getting stale data

.changeset/slow-singers-swim.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Fix for issue #409 LOG_LEVEL Pydantic validation error

.changeset/social-masks-fold.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': minor
+---
+
+Display task complexity scores in task lists, next task, and task details views.

.changeset/soft-zoos-flow.md

@@ -0,0 +1,7 @@
+---
+'task-master-ai': patch
+---
+
+Fix initial .env.example to work out of the box
+
+- Closes #419

.changeset/ten-ways-mate.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Fix default fallback model and maxTokens in Taskmaster initialization

.changeset/tricky-papayas-hang.md

@@ -1,9 +0,0 @@
----
-'task-master-ai': minor
----
-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. 🔥

.changeset/tricky-wombats-spend.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Fix bug when updating tasks on the MCP server (#412)

.changeset/violet-papayas-see.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Fix --task to --num-tasks in ui + related tests - issue #324

.changeset/violet-parrots-march.md

@@ -1,9 +0,0 @@
----
-'task-master-ai': patch
----
-
-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.

.changeset/wide-eyes-relax.md

@@ -0,0 +1,11 @@
+---
+'task-master-ai': patch
+---
+
+Fix duplicate output on CLI help screen
+
+- Prevent the Task Master CLI from printing the help screen more than once when using `-h` or `--help`.
+- Removed redundant manual event handlers and guards for help output; now only the Commander `.helpInformation` override is used for custom help.
+- Simplified logic so that help is only shown once for both "no arguments" and help flag flows.
+- Ensures a clean, branded help experience with no repeated content.
+- Fixes #339

.cursor/rules/architecture.mdc

@@ -65,8 +65,9 @@ alwaysApply: false
   - **[`mcp-server/`](mdc:mcp-server/): MCP Server Integration**
     - **Purpose**: Provides MCP interface using FastMCP.
     - **Responsibilities** (See also: [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)):
-      - Registers tools (`mcp-server/src/tools/*.js`).
-      - Tool `execute` methods call **direct function wrappers** (`mcp-server/src/core/direct-functions/*.js`).
+      - 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.

.cursor/rules/dev_workflow.mdc

@@ -116,7 +116,7 @@ Taskmaster configuration is managed through two main mechanisms:
     *   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.
+**Important:** Non-API key settings (like model selections, `MAX_TOKENS`, `TASKMASTER_LOG_LEVEL`) are **no longer configured via environment variables**. Use the `task-master models` command (or `--setup` for interactive configuration) or the `models` MCP tool.
 **If AI commands FAIL in MCP** verify that the API key for the selected provider is present in the `env` section of `.cursor/mcp.json`.
 **If AI commands FAIL in CLI** verify that the API key for the selected provider is present in the `.env` file in the root of the project.
 

.cursor/rules/mcp.mdc

@@ -188,58 +188,70 @@ execute: async (args, { log, session }) => {
 - **args**: Validated parameters.
 - **context**: Contains `{ log, session }` from FastMCP. (Removed `reportProgress`).
 
-### Standard Tool Execution Pattern
+### Standard Tool Execution Pattern with Path Normalization (Updated)
 
-The `execute` method within each MCP tool (in `mcp-server/src/tools/*.js`) should follow this standard pattern:
+To ensure consistent handling of project paths across different client environments (Windows, macOS, Linux, WSL) and input formats (e.g., `file:///...`, URI encoded paths), all MCP tool `execute` methods that require access to the project root **MUST** be wrapped with the `withNormalizedProjectRoot` Higher-Order Function (HOF).
 
-1.  **Log Entry**: Log the start of the tool execution with relevant arguments.
-2.  **Get Project Root**: Use the `getProjectRootFromSession(session, log)` utility (from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js)) to extract the project root path from the client session. Fall back to `args.projectRoot` if the session doesn't provide a root.
-3.  **Call Direct Function**: Invoke the corresponding `*Direct` function wrapper (e.g., `listTasksDirect` from [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js)), passing an updated `args` object that includes the resolved `projectRoot`. Crucially, the third argument (context) passed to the direct function should **only include `{ log, session }`**. **Do NOT pass `reportProgress`**.
-    ```javascript
-    // Example call (applies to both AI and non-AI direct functions now)
-    const result = await someDirectFunction(
-        { ...args, projectRoot }, // Args including resolved root
-        log,                   // MCP logger
-        { session }            // Context containing session
-    ); 
-    ```
-4.  **Handle Result**: Receive the result object (`{ success, data/error, fromCache }`) from the `*Direct` function.
-5.  **Format Response**: Pass this result object to the `handleApiResult` utility (from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js)) for standardized MCP response formatting and error handling.
-6.  **Return**: Return the formatted response object provided by `handleApiResult`.
+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
-// Example execute method structure for a tool calling an AI-based direct function
-import { getProjectRootFromSession, handleApiResult, createErrorResponse } from './utils.js';
-import { someAIDirectFunction } from '../core/task-master-core.js';
+// 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
 
-// ... inside server.addTool({...})
-execute: async (args, { log, session }) => { // Note: reportProgress is omitted here
-  try {
-    log.info(`Starting AI tool execution with args: ${JSON.stringify(args)}`);
+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;
 
-    // 1. Get Project Root
-    let rootFolder = getProjectRootFromSession(session, log);
-    if (!rootFolder && args.projectRoot) { // Fallback if needed
-      rootFolder = args.projectRoot;
-      log.info(`Using project root from args as fallback: ${rootFolder}`);
-    }
+            try {
+                log.info(`Executing your_tool with normalized root: ${projectRoot}`);
 
-    // 2. Call AI-Based Direct Function (passing only log and session in context)
-    const result = await someAIDirectFunction({
-      ...args,
-      projectRoot: rootFolder // Ensure projectRoot is explicitly passed
-    }, log, { session }); // Pass session here, NO reportProgress
+                // Resolve paths using the normalized projectRoot
+                let tasksPath = findTasksJsonPath({ projectRoot, file: args.file }, log);
 
-    // 3. Handle and Format Response
-    return handleApiResult(result, 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 }
+                );
 
-  } catch (error) {
-    log.error(`Error during AI tool execution: ${error.message}`);
-    return createErrorResponse(error.message);
-  }
+                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:

.cursor/rules/new_features.mdc

@@ -523,14 +523,24 @@ Integrating Task Master commands with the MCP server (for use by tools like Curs
 
 4.  **Create MCP Tool (`mcp-server/src/tools/`)**:
     - Create a new file (e.g., `your-command.js`) using **kebab-case**.
-    - Import `zod`, `handleApiResult`, `createErrorResponse`, **`getProjectRootFromSession`**, and your `yourCommandDirect` function.
+    - Import `zod`, `handleApiResult`, **`withNormalizedProjectRoot` HOF**, and your `yourCommandDirect` function.
     - Implement `registerYourCommandTool(server)`.
-    - Define the tool `name` using **snake_case** (e.g., `your_command`).
-    - Define the `parameters` using `zod`. **Crucially, define `projectRoot` as optional**: `projectRoot: z.string().optional().describe(...)`. Include `file` if applicable.
-    - Implement the standard `async execute(args, { log, reportProgress, session })` method:
-      - Get `rootFolder` using `getProjectRootFromSession` (with fallback to `args.projectRoot`).
-      - Call `yourCommandDirect({ ...args, projectRoot: rootFolder }, log)`. 
-      - Pass the result to `handleApiResult(result, log, 'Error Message')`.
+    - **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`.
 
@@ -618,8 +628,3 @@ When implementing project initialization commands:
      });
    }
    ```
-
-       }
-     });
-   }
-   ```

.cursor/rules/taskmaster.mdc

@@ -79,6 +79,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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.
 
 ---

.cursor/rules/utilities.mdc

@@ -428,36 +428,69 @@ Taskmaster configuration (excluding API keys) is primarily managed through the `
 
 ## MCP Server Tool Utilities (`mcp-server/src/tools/utils.js`)
 
-- **Purpose**: These utilities specifically support the MCP server tools ([`mcp-server/src/tools/*.js`](mdc:mcp-server/src/tools/*.js)), handling MCP communication patterns, response formatting, caching integration, and the CLI fallback mechanism.
-- **Refer to [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)** for detailed usage patterns within the MCP tool `execute` methods and direct function wrappers.
+These utilities specifically support the implementation and execution of MCP tools.
 
-- **`getProjectRootFromSession(session, log)`**: 
-    - ✅ **DO**: Call this utility **within the MCP tool's `execute` method** to extract the project root path from the `session` object.
-    - Decodes the `file://` URI and handles potential errors.
-    - Returns the project path string or `null`.
-    - The returned path should then be passed in the `args` object when calling the corresponding `*Direct` function (e.g., `yourDirectFunction({ ...args, projectRoot: rootFolder }, log)`).
+- **`normalizeProjectRoot(rawPath, log)`**:
+    - **Purpose**: Takes a raw project root path (potentially URI encoded, with `file://` prefix, Windows slashes) and returns a normalized, absolute path suitable for the server's OS.
+    - **Logic**: Decodes URI, strips `file://`, handles Windows drive prefix (`/C:/`), replaces `\` with `/`, uses `path.resolve()`.
+    - **Usage**: Used internally by `withNormalizedProjectRoot` HOF.
+
+- **`getRawProjectRootFromSession(session, log)`**:
+    - **Purpose**: Extracts the *raw* project root URI string from the session object (`session.roots[0].uri` or `session.roots.roots[0].uri`) without performing normalization.
+    - **Usage**: Used internally by `withNormalizedProjectRoot` HOF as a fallback if `args.projectRoot` isn't provided.
+
+- **`withNormalizedProjectRoot(executeFn)`**:
+    - **Purpose**: A Higher-Order Function (HOF) designed to wrap a tool's `execute` method.
+    - **Logic**: 
+        1. Determines the raw project root (from `args.projectRoot` or `getRawProjectRootFromSession`).
+        2. Normalizes the raw path using `normalizeProjectRoot`.
+        3. Injects the normalized, absolute path back into the `args` object as `args.projectRoot`.
+        4. Calls the original `executeFn` with the updated `args`.
+    - **Usage**: Should wrap the `execute` function of *every* MCP tool that needs a reliable, normalized project root path.
+    - **Example**:
+      ```javascript
+      // In mcp-server/src/tools/your-tool.js
+      import { withNormalizedProjectRoot } from './utils.js';
+      
+      export function registerYourTool(server) {
+          server.addTool({
+              // ... name, description, parameters ...
+              execute: withNormalizedProjectRoot(async (args, context) => {
+                  // args.projectRoot is now normalized here
+                  const { projectRoot /*, other args */ } = args;
+                  // ... rest of tool logic using normalized projectRoot ...
+              })
+          });
+      }
+      ```
 
 - **`handleApiResult(result, log, errorPrefix, processFunction)`**:
-    - ✅ **DO**: Call this from the MCP tool's `execute` method after receiving the result from the `*Direct` function wrapper.
-    - Takes the standard `{ success, data/error, fromCache }` object.
-    - Formats the standard MCP success or error response, including the `fromCache` flag.
-    - Uses `processMCPResponseData` by default to filter response data.
-
-- **`executeTaskMasterCommand(command, log, args, projectRootRaw)`**:
-    - Executes a Task Master CLI command as a child process.
-    - Handles fallback between global `task-master` and local `node scripts/dev.js`.
-    - ❌ **DON'T**: Use this as the primary method for MCP tools. Prefer direct function calls via `*Direct` wrappers.
-
-- **`processMCPResponseData(taskOrData, fieldsToRemove)`**:
-    - Filters task data (e.g., removing `details`, `testStrategy`) before sending to the MCP client. Called by `handleApiResult`.
+    - **Purpose**: Standardizes the formatting of responses returned by direct functions (`{ success, data/error, fromCache }`) into the MCP response format.
+    - **Usage**: Call this at the end of the tool's `execute` method, passing the result from the direct function call.
 
 - **`createContentResponse(content)` / `createErrorResponse(errorMessage)`**:
-    - Formatters for standard MCP success/error responses.
+    - **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* to implement caching.
-    - Checks cache, executes `actionFn` on miss, stores result.
-    - Returns standard `{ 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.
+
+- **`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`.
+
+- **`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
 

.github/workflows/pre-release.yml

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

.github/workflows/release.yml

@@ -33,6 +33,9 @@ jobs:
         run: npm ci
         timeout-minutes: 2
 
+      - name: Exit pre-release mode (safety check)
+        run: npx changeset pre exit || true
+
       - name: Create Release Pull Request or Publish to npm
         uses: changesets/action@v1
         with:

.gitignore

@@ -61,3 +61,6 @@ dist
 *.debug
 init-debug.log
 dev-debug.log
+
+# NPMRC
+.npmrc

.taskmasterconfig

@@ -14,7 +14,7 @@
     },
     "fallback": {
       "provider": "anthropic",
-      "modelId": "claude-3-5-sonnet-20241022",
+      "modelId": "claude-3-7-sonnet-20250219",
       "maxTokens": 120000,
       "temperature": 0.2
     }

CHANGELOG.md

@@ -1,5 +1,77 @@
 # task-master-ai
 
+## 0.13.1
+
+### Patch Changes
+
+- [#399](https://github.com/eyaltoledano/claude-task-master/pull/399) [`734a4fd`](https://github.com/eyaltoledano/claude-task-master/commit/734a4fdcfc89c2e089255618cf940561ad13a3c8) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix ERR_MODULE_NOT_FOUND when trying to run MCP Server
+
+## 0.13.0
+
+### Minor Changes
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`ef782ff`](https://github.com/eyaltoledano/claude-task-master/commit/ef782ff5bd4ceb3ed0dc9ea82087aae5f79ac933) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - feat(expand): Enhance `expand` and `expand-all` commands
+
+  - Integrate `task-complexity-report.json` to automatically determine the number of subtasks and use tailored prompts for expansion based on prior analysis. You no longer need to try copy-pasting the recommended prompt. If it exists, it will use it for you. You can just run `task-master update --id=[id of task] --research` and it will use that prompt automatically. No extra prompt needed.
+  - Change default behavior to _append_ new subtasks to existing ones. Use the `--force` flag to clear existing subtasks before expanding. This is helpful if you need to add more subtasks to a task but you want to do it by the batch from a given prompt. Use force if you want to start fresh with a task's subtasks.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`87d97bb`](https://github.com/eyaltoledano/claude-task-master/commit/87d97bba00d84e905756d46ef96b2d5b984e0f38) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds support for the OpenRouter AI provider. Users can now configure models available through OpenRouter (requiring an `OPENROUTER_API_KEY`) via the `task-master models` command, granting access to a wide range of additional LLMs. - IMPORTANT FYI ABOUT OPENROUTER: Taskmaster relies on AI SDK, which itself relies on tool use. It looks like **free** models sometimes do not include tool use. For example, Gemini 2.5 pro (free) failed via OpenRouter (no tool use) but worked fine on the paid version of the model. Custom model support for Open Router is considered experimental and likely will not be further improved for some time.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`1ab836f`](https://github.com/eyaltoledano/claude-task-master/commit/1ab836f191cb8969153593a9a0bd47fc9aa4a831) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds model management and new configuration file .taskmasterconfig which houses the models used for main, research and fallback. Adds models command and setter flags. Adds a --setup flag with an interactive setup. We should be calling this during init. Shows a table of active and available models when models is called without flags. Includes SWE scores and token costs, which are manually entered into the supported_models.json, the new place where models are defined for support. Config-manager.js is the core module responsible for managing the new config."
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`c8722b0`](https://github.com/eyaltoledano/claude-task-master/commit/c8722b0a7a443a73b95d1bcd4a0b68e0fce2a1cd) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds custom model ID support for Ollama and OpenRouter providers.
+
+  - Adds the `--ollama` and `--openrouter` flags to `task-master models --set-<role>` command to set models for those providers outside of the support models list.
+  - Updated `task-master models --setup` interactive mode with options to explicitly enter custom Ollama or OpenRouter model IDs.
+  - Implemented live validation against OpenRouter API (`/api/v1/models`) when setting a custom OpenRouter model ID (via flag or setup).
+  - Refined logic to prioritize explicit provider flags/choices over internal model list lookups in case of ID conflicts.
+  - Added warnings when setting custom/unvalidated models.
+  - We obviously don't recommend going with a custom, unproven model. If you do and find performance is good, please let us know so we can add it to the list of supported models.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`2517bc1`](https://github.com/eyaltoledano/claude-task-master/commit/2517bc112c9a497110f3286ca4bfb4130c9addcb) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Integrate OpenAI as a new AI provider. - Enhance `models` command/tool to display API key status. - Implement model-specific `maxTokens` override based on `supported-models.json` to save you if you use an incorrect max token value.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`9a48278`](https://github.com/eyaltoledano/claude-task-master/commit/9a482789f7894f57f655fb8d30ba68542bd0df63) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Tweaks Perplexity AI calls for research mode to max out input tokens and get day-fresh information - Forces temp at 0.1 for highly deterministic output, no variations - Adds a system prompt to further improve the output - Correctly uses the maximum input tokens (8,719, used 8,700) for perplexity - Specificies to use a high degree of research across the web - Specifies to use information that is as fresh as today; this support stuff like capturing brand new announcements like new GPT models and being able to query for those in research. 🔥
+
+### Patch Changes
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`842eaf7`](https://github.com/eyaltoledano/claude-task-master/commit/842eaf722498ddf7307800b4cdcef4ac4fd7e5b0) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - - Add support for Google Gemini models via Vercel AI SDK integration.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`ed79d4f`](https://github.com/eyaltoledano/claude-task-master/commit/ed79d4f4735dfab4124fa189214c0bd5e23a6860) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add xAI provider and Grok models support
+
+- [#378](https://github.com/eyaltoledano/claude-task-master/pull/378) [`ad89253`](https://github.com/eyaltoledano/claude-task-master/commit/ad89253e313a395637aa48b9f92cc39b1ef94ad8) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Better support for file paths on Windows, Linux & WSL.
+
+  - Standardizes handling of different path formats (URI encoded, Windows, Linux, WSL).
+  - Ensures tools receive a clean, absolute path suitable for the server OS.
+  - Simplifies tool implementation by centralizing normalization logic.
+
+- [#285](https://github.com/eyaltoledano/claude-task-master/pull/285) [`2acba94`](https://github.com/eyaltoledano/claude-task-master/commit/2acba945c0afee9460d8af18814c87e80f747e9f) Thanks [@neno-is-ooo](https://github.com/neno-is-ooo)! - Add integration for Roo Code
+
+- [#378](https://github.com/eyaltoledano/claude-task-master/pull/378) [`d63964a`](https://github.com/eyaltoledano/claude-task-master/commit/d63964a10eed9be17856757661ff817ad6bacfdc) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Improved update-subtask - Now it has context about the parent task details - It also has context about the subtask before it and the subtask after it (if they exist) - Not passing all subtasks to stay token efficient
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`5f504fa`](https://github.com/eyaltoledano/claude-task-master/commit/5f504fafb8bdaa0043c2d20dee8bbb8ec2040d85) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Improve and adjust `init` command for robustness and updated dependencies.
+
+  - **Update Initialization Dependencies:** Ensure newly initialized projects (`task-master init`) include all required AI SDK dependencies (`@ai-sdk/*`, `ai`, provider wrappers) in their `package.json` for out-of-the-box AI feature compatibility. Remove unnecessary dependencies (e.g., `uuid`) from the init template.
+  - **Silence `npm install` during `init`:** Prevent `npm install` output from interfering with non-interactive/MCP initialization by suppressing its stdio in silent mode.
+  - **Improve Conditional Model Setup:** Reliably skip interactive `models --setup` during non-interactive `init` runs (e.g., `init -y` or MCP) by checking `isSilentMode()` instead of passing flags.
+  - **Refactor `init.js`:** Remove internal `isInteractive` flag logic.
+  - **Update `init` Instructions:** Tweak the "Getting Started" text displayed after `init`.
+  - **Fix MCP Server Launch:** Update `.cursor/mcp.json` template to use `node ./mcp-server/server.js` instead of `npx task-master-mcp`.
+  - **Update Default Model:** Change the default main model in the `.taskmasterconfig` template.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`96aeeff`](https://github.com/eyaltoledano/claude-task-master/commit/96aeeffc195372722c6a07370540e235bfe0e4d8) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue with add-task which did not use the manually defined properties and still needlessly hit the AI endpoint.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`5aea93d`](https://github.com/eyaltoledano/claude-task-master/commit/5aea93d4c0490c242d7d7042a210611977848e0a) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue that prevented remove-subtask with comma separated tasks/subtasks from being deleted (only the first ID was being deleted). Closes #140
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`66ac9ab`](https://github.com/eyaltoledano/claude-task-master/commit/66ac9ab9f66d006da518d6e8a3244e708af2764d) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Improves next command to be subtask-aware - The logic for determining the "next task" (findNextTask function, used by task-master next and the next_task MCP tool) has been significantly improved. Previously, it only considered top-level tasks, making its recommendation less useful when a parent task containing subtasks was already marked 'in-progress'. - The updated logic now prioritizes finding the next available subtask within any 'in-progress' parent task, considering subtask dependencies and priority. - If no suitable subtask is found within active parent tasks, it falls back to recommending the next eligible top-level task based on the original criteria (status, dependencies, priority).
+
+  This change makes the next command much more relevant and helpful during the implementation phase of complex tasks.
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`ca7b045`](https://github.com/eyaltoledano/claude-task-master/commit/ca7b0457f1dc65fd9484e92527d9fd6d69db758d) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add `--status` flag to `show` command to filter displayed subtasks.
+
+- [#328](https://github.com/eyaltoledano/claude-task-master/pull/328) [`5a2371b`](https://github.com/eyaltoledano/claude-task-master/commit/5a2371b7cc0c76f5e95d43921c1e8cc8081bf14e) Thanks [@knoxgraeme](https://github.com/knoxgraeme)! - Fix --task to --num-tasks in ui + related tests - issue #324
+
+- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`6cb213e`](https://github.com/eyaltoledano/claude-task-master/commit/6cb213ebbd51116ae0688e35b575d09443d17c3b) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds a 'models' CLI and MCP command to get the current model configuration, available models, and gives the ability to set main/research/fallback models." - In the CLI, `task-master models` shows the current models config. Using the `--setup` flag launches an interactive set up that allows you to easily select the models you want to use for each of the three roles. Use `q` during the interactive setup to cancel the setup. - In the MCP, responses are simplified in RESTful format (instead of the full CLI output). The agent can use the `models` tool with different arguments, including `listAvailableModels` to get available models. Run without arguments, it will return the current configuration. Arguments are available to set the model for each of the three roles. This allows you to manage Taskmaster AI providers and models directly from either the CLI or MCP or both. - Updated the CLI help menu when you run `task-master` to include missing commands and .taskmasterconfig information. - Adds `--research` flag to `add-task` so you can hit up Perplexity right from the add-task flow, rather than having to add a task and then update it.
+
 ## 0.12.1
 
 ### Patch Changes

README-task-master.md

@@ -47,7 +47,7 @@ npm install task-master-ai
 task-master init
 
 # If installed locally
-npx task-master-init
+npx task-master init
 ```
 
 This will prompt you for project details and set up a new project with the necessary files and structure.

assets/.taskmasterconfig

@@ -14,8 +14,8 @@
 		},
 		"fallback": {
 			"provider": "anthropic",
-			"modelId": "claude-3.5-sonnet-20240620",
-			"maxTokens": 120000,
+			"modelId": "claude-3-5-sonnet-20240620",
+			"maxTokens": 8192,
 			"temperature": 0.1
 		}
 	},

assets/.windsurfrules

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

assets/env.example

@@ -1,8 +1,8 @@
 # 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).
+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/scripts_README.md

@@ -31,7 +31,7 @@ Task Master configuration is now managed through two primary methods:
     - 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.
+**Important:** Settings like `MODEL`, `MAX_TOKENS`, `TEMPERATURE`, `TASKMASTER_LOG_LEVEL`, etc., are **no longer set via `.env`**. Use `task-master models --setup` instead.
 
 ## How It Works
 
@@ -42,7 +42,7 @@ Task Master configuration is now managed through two primary methods:
    - Tasks can have `subtasks` for more detailed implementation steps.
    - Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending) to easily track progress.
 
-2. **CLI Commands**  
+2. **CLI Commands**
    You can run the commands via:
 
    ```bash
@@ -200,7 +200,7 @@ Notes:
 
 ## Logging
 
-The script supports different logging levels controlled by the `LOG_LEVEL` environment variable:
+The script supports different logging levels controlled by the `TASKMASTER_LOG_LEVEL` environment variable:
 
 - `debug`: Detailed information, typically useful for troubleshooting
 - `info`: Confirmation that things are working as expected (default)

docs/configuration.md

@@ -15,13 +15,15 @@ Taskmaster uses two primary methods for configuration:
       			"provider": "anthropic",
       			"modelId": "claude-3-7-sonnet-20250219",
       			"maxTokens": 64000,
-      			"temperature": 0.2
+      			"temperature": 0.2,
+      			"baseUrl": "https://api.anthropic.com/v1"
       		},
       		"research": {
       			"provider": "perplexity",
       			"modelId": "sonar-pro",
       			"maxTokens": 8700,
-      			"temperature": 0.1
+      			"temperature": 0.1,
+      			"baseUrl": "https://api.perplexity.ai/v1"
       		},
       		"fallback": {
       			"provider": "anthropic",
@@ -56,8 +58,9 @@ Taskmaster uses two primary methods for configuration:
       - `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.
+    - **Optional Endpoint Overrides:**
+      - **Per-role `baseUrl` in `.taskmasterconfig`:** You can add a `baseUrl` property to any model role (`main`, `research`, `fallback`) to override the default API endpoint for that provider. If omitted, the provider's standard endpoint is used.
+      - `AZURE_OPENAI_ENDPOINT`: Required if using Azure OpenAI key (can also be set as `baseUrl` for the Azure model role).
       - `OLLAMA_BASE_URL`: Override the default Ollama API URL (Default: `http://localhost:11434/api`).
 
 **Important:** Settings like model ID selections (`main`, `research`, `fallback`), `maxTokens`, `temperature`, `logLevel`, `defaultSubtasks`, `defaultPriority`, and `projectName` are **managed in `.taskmasterconfig`**, not environment variables.

docs/tutorial.md

@@ -89,7 +89,7 @@ Initialize a new project:
 task-master init
 
 # If installed locally
-npx task-master-init
+npx task-master init
 ```
 
 This will prompt you for project details and set up a new project with the necessary files and structure.

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

@@ -8,7 +8,6 @@ import {
 	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.
@@ -86,30 +85,20 @@ export async function complexityReportDirect(args, log) {
 
 		// 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 }
+			const result = await coreActionFn();
+			log.info('complexityReportDirect completed');
+			return result;
 		} catch (error) {
-			// Catch unexpected errors from getCachedOrExecute itself
 			// Ensure silent mode is disabled
 			disableSilentMode();
 
-			log.error(
-				`Unexpected error during getCachedOrExecute for complexityReport: ${error.message}`
-			);
+			log.error(`Unexpected error during complexityReport: ${error.message}`);
 			return {
 				success: false,
 				error: {
 					code: 'UNEXPECTED_ERROR',
 					message: error.message
-				},
-				fromCache: false
+				}
 			};
 		}
 	} catch (error) {

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

@@ -4,7 +4,6 @@ import {
 	disableSilentMode
 	// isSilentMode // Not used directly here
 } from '../../../../scripts/modules/utils.js';
-import { getProjectRootFromSession } from '../../tools/utils.js'; // Adjust path if necessary
 import os from 'os'; // Import os module for home directory check
 
 /**
@@ -16,60 +15,32 @@ import os from 'os'; // Import os module for home directory check
  * @returns {Promise<{success: boolean, data?: any, error?: {code: string, message: string}}>} - Standard result object.
  */
 export async function initializeProjectDirect(args, log, context = {}) {
-	const { session } = context;
+	const { session } = context; // Keep session if core logic needs it
 	const homeDir = os.homedir();
-	let targetDirectory = null;
 
-	log.info(
-		`CONTEXT received in direct function: ${context ? JSON.stringify(Object.keys(context)) : 'MISSING or Falsy'}`
-	);
-	log.info(
-		`SESSION extracted in direct function: ${session ? 'Exists' : 'MISSING or Falsy'}`
-	);
 	log.info(`Args received in direct function: ${JSON.stringify(args)}`);
 
 	// --- Determine Target Directory ---
-	// 1. Prioritize projectRoot passed directly in args
-	// Ensure it's not null, '/', or the home directory
-	if (
-		args.projectRoot &&
-		args.projectRoot !== '/' &&
-		args.projectRoot !== homeDir
-	) {
-		log.info(`Using projectRoot directly from args: ${args.projectRoot}`);
-		targetDirectory = args.projectRoot;
-	} else {
-		// 2. If args.projectRoot is missing or invalid, THEN try session (as a fallback)
-		log.warn(
-			`args.projectRoot ('${args.projectRoot}') is missing or invalid. Attempting to derive from session.`
-		);
-		const sessionDerivedPath = getProjectRootFromSession(session, log);
-		// Validate the session-derived path as well
-		if (
-			sessionDerivedPath &&
-			sessionDerivedPath !== '/' &&
-			sessionDerivedPath !== homeDir
-		) {
-			log.info(
-				`Using project root derived from session: ${sessionDerivedPath}`
-			);
-			targetDirectory = sessionDerivedPath;
-		} else {
-			log.error(
-				`Could not determine a valid project root. args.projectRoot='${args.projectRoot}', sessionDerivedPath='${sessionDerivedPath}'`
-			);
-		}
-	}
+	// 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;
 
-	// 3. Validate the final targetDirectory
-	if (!targetDirectory) {
-		// This error now covers cases where neither args.projectRoot nor session provided a valid path
+	// --- 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: Could not determine a valid target directory. Please ensure a workspace/folder is open or specify projectRoot.`,
-				details: `Attempted args.projectRoot: ${args.projectRoot}`
+				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
 		};
@@ -86,11 +57,12 @@ export async function initializeProjectDirect(args, log, context = {}) {
 	log.info(
 		`Temporarily changing CWD to ${targetDirectory} for initialization.`
 	);
-	process.chdir(targetDirectory); // Change CWD to the *validated* targetDirectory
+	process.chdir(targetDirectory); // Change CWD to the HOF-provided root
 
-	enableSilentMode(); // Enable silent mode BEFORE calling the core function
+	enableSilentMode();
 	try {
-		// Always force yes: true when called via MCP to avoid interactive prompts
+		// 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,
@@ -100,12 +72,11 @@ export async function initializeProjectDirect(args, log, context = {}) {
 		log.info(`Initializing project with options: ${JSON.stringify(options)}`);
 		const result = await initializeProject(options); // Call core logic
 
-		// Format success result for handleApiResult
 		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 // Include details returned by initializeProject
+			...result
 		};
 		success = true;
 		log.info(
@@ -120,12 +91,11 @@ export async function initializeProjectDirect(args, log, context = {}) {
 		};
 		success = false;
 	} finally {
-		disableSilentMode(); // ALWAYS disable silent mode in finally
+		disableSilentMode();
 		log.info(`Restoring original CWD: ${originalCwd}`);
-		process.chdir(originalCwd); // Change back to original CWD
+		process.chdir(originalCwd);
 	}
 
-	// Return in format expected by handleApiResult
 	if (success) {
 		return { success: true, data: resultData, fromCache: false };
 	} else {

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

@@ -4,7 +4,6 @@
  */
 
 import { listTasks } from '../../../../scripts/modules/task-manager.js';
-import { getCachedOrExecute } from '../../tools/utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -19,7 +18,7 @@ import {
  */
 export async function listTasksDirect(args, log) {
 	// Destructure the explicit tasksJsonPath from args
-	const { tasksJsonPath, status, withSubtasks } = args;
+	const { tasksJsonPath, reportPath, status, withSubtasks } = args;
 
 	if (!tasksJsonPath) {
 		log.error('listTasksDirect called without tasksJsonPath');
@@ -36,7 +35,6 @@ export async function listTasksDirect(args, log) {
 	// 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 () => {
@@ -51,6 +49,7 @@ export async function listTasksDirect(args, log) {
 			const resultData = listTasks(
 				tasksJsonPath,
 				statusFilter,
+				reportPath,
 				withSubtasksFilter,
 				'json'
 			);
@@ -65,6 +64,7 @@ export async function listTasksDirect(args, log) {
 					}
 				};
 			}
+
 			log.info(
 				`Core listTasks function retrieved ${resultData.tasks.length} tasks`
 			);
@@ -88,25 +88,19 @@ export async function listTasksDirect(args, log) {
 		}
 	};
 
-	// 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 }
+		const result = await coreListTasksAction();
+		log.info('listTasksDirect completed');
+		return result;
 	} catch (error) {
-		// Catch unexpected errors from getCachedOrExecute itself (though unlikely)
-		log.error(
-			`Unexpected error during getCachedOrExecute for listTasks: ${error.message}`
-		);
+		log.error(`Unexpected error during listTasks: ${error.message}`);
 		console.error(error.stack);
 		return {
 			success: false,
-			error: { code: 'CACHE_UTIL_ERROR', message: error.message },
-			fromCache: false
+			error: {
+				code: 'UNEXPECTED_ERROR',
+				message: error.message
+			}
 		};
 	}
 }

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

@@ -4,8 +4,10 @@
  */
 
 import { findNextTask } from '../../../../scripts/modules/task-manager.js';
-import { readJSON } from '../../../../scripts/modules/utils.js';
-import { getCachedOrExecute } from '../../tools/utils.js';
+import {
+	readJSON,
+	readComplexityReport
+} from '../../../../scripts/modules/utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -21,7 +23,7 @@ import {
  */
 export async function nextTaskDirect(args, log) {
 	// Destructure expected args
-	const { tasksJsonPath } = args;
+	const { tasksJsonPath, reportPath } = args;
 
 	if (!tasksJsonPath) {
 		log.error('nextTaskDirect called without tasksJsonPath');
@@ -35,9 +37,6 @@ export async function nextTaskDirect(args, log) {
 		};
 	}
 
-	// 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 {
@@ -59,8 +58,11 @@ export async function nextTaskDirect(args, log) {
 				};
 			}
 
+			// Read the complexity report
+			const complexityReport = readComplexityReport(reportPath);
+
 			// Find the next task
-			const nextTask = findNextTask(data.tasks);
+			const nextTask = findNextTask(data.tasks, complexityReport);
 
 			if (!nextTask) {
 				log.info(
@@ -71,24 +73,34 @@ export async function nextTaskDirect(args, log) {
 					data: {
 						message:
 							'No eligible next task found. All tasks are either completed or have unsatisfied dependencies',
-						nextTask: null,
-						allTasks: data.tasks
+						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}`
+				`Successfully found next task ${nextTask.id}: ${nextTask.title}. Is subtask: ${isSubtask}`
 			);
 			return {
 				success: true,
 				data: {
 					nextTask,
-					allTasks: data.tasks
+					isSubtask,
+					nextSteps: `When ready to work on the ${taskOrSubtask}, use set-status to set the status to "in progress" ${additionalAdvice}`
 				}
 			};
 		} catch (error) {
@@ -108,18 +120,11 @@ export async function nextTaskDirect(args, log) {
 
 	// 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 }
+		const result = await coreNextTaskAction();
+		log.info(`nextTaskDirect completed.`);
+		return result;
 	} catch (error) {
-		// Catch unexpected errors from getCachedOrExecute itself
-		log.error(
-			`Unexpected error during getCachedOrExecute for nextTask: ${error.message}`
-		);
+		log.error(`Unexpected error during nextTask: ${error.message}`);
 		return {
 			success: false,
 			error: {

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

@@ -34,18 +34,17 @@ export async function parsePRDDirect(args, log, context = {}) {
 		projectRoot
 	} = args;
 
+	// Create the standard logger wrapper
 	const logWrapper = createLogWrapper(log);
 
 	// --- Input Validation and Path Resolution ---
-	if (!projectRoot || !path.isAbsolute(projectRoot)) {
-		logWrapper.error(
-			'parsePRDDirect requires an absolute projectRoot argument.'
-		);
+	if (!projectRoot) {
+		logWrapper.error('parsePRDDirect requires a projectRoot argument.');
 		return {
 			success: false,
 			error: {
 				code: 'MISSING_ARGUMENT',
-				message: 'projectRoot is required and must be absolute.'
+				message: 'projectRoot is required.'
 			}
 		};
 	}
@@ -57,7 +56,7 @@ export async function parsePRDDirect(args, log, context = {}) {
 		};
 	}
 
-	// Resolve input and output paths relative to projectRoot if they aren't absolute
+	// Resolve input and output paths relative to projectRoot
 	const inputPath = path.resolve(projectRoot, inputArg);
 	const outputPath = outputArg
 		? path.resolve(projectRoot, outputArg)
@@ -101,7 +100,7 @@ export async function parsePRDDirect(args, log, context = {}) {
 			// Ensure positive number
 			numTasks = getDefaultNumTasks(projectRoot); // Fallback to default if parsing fails or invalid
 			logWrapper.warn(
-				`Invalid numTasks value: ${numTasksArg}. Using default: 10`
+				`Invalid numTasks value: ${numTasksArg}. Using default: ${numTasks}`
 			);
 		}
 	}
@@ -147,7 +146,6 @@ export async function parsePRDDirect(args, log, context = {}) {
 					message: `Successfully parsed PRD and generated ${result.tasks.length} tasks.`,
 					outputPath: outputPath,
 					taskCount: result.tasks.length
-					// Optionally include tasks if needed by client: tasks: result.tasks
 				}
 			};
 		} else {

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

@@ -3,151 +3,103 @@
  * Direct function implementation for showing task details
  */
 
-import { findTaskById } from '../../../../scripts/modules/utils.js';
-import { readJSON } from '../../../../scripts/modules/utils.js';
-import { getCachedOrExecute } from '../../tools/utils.js';
 import {
-	enableSilentMode,
-	disableSilentMode
+	findTaskById,
+	readComplexityReport,
+	readJSON
 } from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 
 /**
- * Direct function wrapper for showing task details with error handling and caching.
+ * Direct function wrapper for getting task details.
  *
- * @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 or subtask to show.
+ * @param {Object} args - Command arguments.
+ * @param {string} args.id - Task ID to show.
+ * @param {string} [args.file] - Optional path to the tasks file (passed to findTasksJsonPath).
+ * @param {string} args.reportPath - Explicit path to the complexity report file.
  * @param {string} [args.status] - Optional status to filter subtasks by.
- * @param {Object} log - Logger object
- * @returns {Promise<Object>} - Task details result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
+ * @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 expected args
-	const { tasksJsonPath, id, status } = args;
+	// Destructure session from context if needed later, otherwise ignore
+	// const { session } = context;
+	// Destructure projectRoot and other args. projectRoot is assumed normalized.
+	const { id, file, reportPath, status, projectRoot } = args;
 
-	if (!tasksJsonPath) {
-		log.error('showTaskDirect called without tasksJsonPath');
+	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: 'MISSING_ARGUMENT',
-				message: 'tasksJsonPath is required'
-			},
-			fromCache: false
+				code: 'TASKS_FILE_NOT_FOUND',
+				message: `Failed to find tasks.json: ${error.message}`
+			}
 		};
 	}
+	// --- End Path Resolution ---
 
-	// Validate task ID
-	const taskId = id;
-	if (!taskId) {
-		log.error('Task ID is required');
-		return {
-			success: false,
-			error: {
-				code: 'INPUT_VALIDATION_ERROR',
-				message: 'Task ID is required'
-			},
-			fromCache: false
-		};
-	}
-
-	// Generate cache key using the provided task path, ID, and status filter
-	const cacheKey = `showTask:${tasksJsonPath}:${taskId}:${status || 'all'}`;
-
-	// Define the action function to be executed on cache miss
-	const coreShowTaskAction = async () => {
-		try {
-			// Enable silent mode to prevent console logs from interfering with JSON response
-			enableSilentMode();
-
-			log.info(
-				`Retrieving task details for ID: ${taskId} from ${tasksJsonPath}${status ? ` (filtering by status: ${status})` : ''}`
-			);
-
-			// Read tasks data using the provided path
-			const data = readJSON(tasksJsonPath);
-			if (!data || !data.tasks) {
-				disableSilentMode(); // Disable before returning
-				return {
-					success: false,
-					error: {
-						code: 'INVALID_TASKS_FILE',
-						message: `No valid tasks found in ${tasksJsonPath}`
-					}
-				};
-			}
-
-			// Find the specific task, passing the status filter
-			const { task, originalSubtaskCount } = findTaskById(
-				data.tasks,
-				taskId,
-				status
-			);
-
-			if (!task) {
-				disableSilentMode(); // Disable before returning
-				return {
-					success: false,
-					error: {
-						code: 'TASK_NOT_FOUND',
-						message: `Task with ID ${taskId} not found${status ? ` or no subtasks match status '${status}'` : ''}`
-					}
-				};
-			}
-
-			// Restore normal logging
-			disableSilentMode();
-
-			// Return the task data, the original subtask count (if applicable),
-			// and the full tasks array for reference (needed for formatDependenciesWithStatus function in UI)
-			log.info(
-				`Successfully found task ${taskId}${status ? ` (with status filter: ${status})` : ''}`
-			);
+	// --- Rest of the function remains the same, using tasksJsonPath ---
+	try {
+		const tasksData = readJSON(tasksJsonPath);
+		if (!tasksData || !tasksData.tasks) {
 			return {
-				success: true,
-				data: {
-					task,
-					originalSubtaskCount,
-					allTasks: data.tasks
-				}
+				success: false,
+				error: { code: 'INVALID_TASKS_DATA', message: 'Invalid tasks data' }
 			};
-		} catch (error) {
-			// Make sure to restore normal logging even if there's an error
-			disableSilentMode();
+		}
 
-			log.error(`Error showing task: ${error.message}`);
+		const complexityReport = readComplexityReport(reportPath);
+
+		const { task, originalSubtaskCount } = findTaskById(
+			tasksData.tasks,
+			id,
+			complexityReport,
+			status
+		);
+
+		if (!task) {
 			return {
 				success: false,
 				error: {
-					code: 'CORE_FUNCTION_ERROR',
-					message: error.message || 'Failed to show task details'
+					code: 'TASK_NOT_FOUND',
+					message: `Task or subtask with ID ${id} not found`
 				}
 			};
 		}
-	};
 
-	// Use the caching utility
-	try {
-		const result = await getCachedOrExecute({
-			cacheKey,
-			actionFn: coreShowTaskAction,
-			log
-		});
-		log.info(`showTaskDirect completed. From cache: ${result.fromCache}`);
-		return result; // Returns { success, data/error, fromCache }
+		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) {
-		// Catch unexpected errors from getCachedOrExecute itself
-		disableSilentMode();
-		log.error(
-			`Unexpected error during getCachedOrExecute for showTask: ${error.message}`
-		);
+		log.error(`Error showing task ${id}: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'UNEXPECTED_ERROR',
+				code: 'TASK_OPERATION_ERROR',
 				message: error.message
-			},
-			fromCache: false
+			}
 		};
 	}
 }

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

@@ -1,130 +1,126 @@
 /**
  * update-tasks.js
- * Direct function implementation for updating tasks based on new context/prompt
+ * 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';
 import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { createLogWrapper } from '../../tools/utils.js';
 
 /**
- * Direct function wrapper for updating tasks based on new context/prompt.
+ * Direct function wrapper for updating tasks based on new context.
  *
- * @param {Object} args - Command arguments containing from, prompt, research and tasksJsonPath.
+ * @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; // Extract session
-	const { tasksJsonPath, from, prompt, research, projectRoot } = args;
+	const { session } = context;
+	const { from, prompt, research, file: fileArg, projectRoot } = args;
 
 	// Create the standard logger wrapper
-	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)
-	};
+	const logWrapper = createLogWrapper(log);
 
-	// --- Input Validation (Keep existing checks) ---
-	if (!tasksJsonPath) {
-		log.error('updateTasksDirect called without tasksJsonPath');
-		return {
-			success: false,
-			error: { code: 'MISSING_ARGUMENT', message: 'tasksJsonPath is required' },
-			fromCache: false
-		};
-	}
-	if (args.id !== undefined && from === undefined) {
-		// Keep 'from' vs 'id' check
-		const errorMessage =
-			"Use 'from' parameter, not 'id', or use 'update_task' tool.";
-		log.error(errorMessage);
-		return {
-			success: false,
-			error: { code: 'PARAMETER_MISMATCH', message: errorMessage },
-			fromCache: false
-		};
-	}
-	if (!from) {
-		log.error('Missing from ID.');
-		return {
-			success: false,
-			error: { code: 'MISSING_FROM_ID', message: 'No from ID specified.' },
-			fromCache: false
-		};
-	}
-	if (!prompt) {
-		log.error('Missing prompt.');
-		return {
-			success: false,
-			error: { code: 'MISSING_PROMPT', message: 'No prompt specified.' },
-			fromCache: false
-		};
-	}
-	let fromId;
-	try {
-		fromId = parseInt(from, 10);
-		if (isNaN(fromId) || fromId <= 0) throw new Error();
-	} catch {
-		log.error(`Invalid from ID: ${from}`);
+	// --- Input Validation ---
+	if (!projectRoot) {
+		logWrapper.error('updateTasksDirect requires a projectRoot argument.');
 		return {
 			success: false,
 			error: {
-				code: 'INVALID_FROM_ID',
-				message: `Invalid from ID: ${from}. Must be a positive integer.`
-			},
-			fromCache: false
+				code: 'MISSING_ARGUMENT',
+				message: 'projectRoot is required.'
+			}
 		};
 	}
-	const useResearch = research === true;
-	// --- End Input Validation ---
 
-	log.info(
-		`Updating tasks from ID ${fromId}. Research: ${useResearch}. Project Root: ${projectRoot}`
+	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 {
-		// Create logger wrapper using the utility
-		const mcpLog = createLogWrapper(log);
-
-		// Execute core updateTasks function, passing session context AND projectRoot
-		await updateTasks(
-			tasksJsonPath,
-			fromId,
+		// Call the core updateTasks function
+		const result = await updateTasks(
+			tasksFile,
+			from,
 			prompt,
-			useResearch,
-			// Pass context with logger wrapper, session, AND projectRoot
-			{ mcpLog, session, projectRoot },
-			'json' // Explicitly request JSON format for MCP
+			research,
+			{
+				session,
+				mcpLog: logWrapper,
+				projectRoot
+			},
+			'json'
 		);
 
-		// Since updateTasks modifies file and doesn't return data, create success message
-		return {
-			success: true,
-			data: {
-				message: `Successfully initiated update for tasks from ID ${fromId} based on the prompt.`,
-				fromId,
-				tasksPath: tasksJsonPath,
-				useResearch
-			},
-			fromCache: false // Modifies state
-		};
+		// 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) {
-		log.error(`Error executing core updateTasks: ${error.message}`);
+		logWrapper.error(`Error executing core updateTasks: ${error.message}`);
 		return {
 			success: false,
 			error: {
 				code: 'UPDATE_TASKS_CORE_ERROR',
 				message: error.message || 'Unknown error updating tasks'
-			},
-			fromCache: false
+			}
 		};
 	} finally {
 		disableSilentMode(); // Ensure silent mode is disabled

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

@@ -28,7 +28,7 @@ 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-direct.js';
+import { initializeProjectDirect } from './direct-functions/initialize-project.js';
 import { modelsDirect } from './direct-functions/models.js';
 
 // Re-export utility functions

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

@@ -339,6 +339,49 @@ export function findPRDDocumentPath(projectRoot, explicitPath, log) {
 	return null;
 }
 
+export function findComplexityReportPath(projectRoot, explicitPath, log) {
+	// If explicit path is provided, check if it exists
+	if (explicitPath) {
+		const fullPath = path.isAbsolute(explicitPath)
+			? explicitPath
+			: path.resolve(projectRoot, explicitPath);
+
+		if (fs.existsSync(fullPath)) {
+			log.info(`Using provided PRD document path: ${fullPath}`);
+			return fullPath;
+		} else {
+			log.warn(
+				`Provided PRD document path not found: ${fullPath}, will search for alternatives`
+			);
+		}
+	}
+
+	// Common locations and file patterns for PRD documents
+	const commonLocations = [
+		'', // Project root
+		'scripts/'
+	];
+
+	const commonFileNames = [
+		'complexity-report.json',
+		'task-complexity-report.json'
+	];
+
+	// Check all possible combinations
+	for (const location of commonLocations) {
+		for (const fileName of commonFileNames) {
+			const potentialPath = path.join(projectRoot, location, fileName);
+			if (fs.existsSync(potentialPath)) {
+				log.info(`Found PRD document at: ${potentialPath}`);
+				return potentialPath;
+			}
+		}
+	}
+
+	log.warn(`No PRD document found in common locations within ${projectRoot}`);
+	return null;
+}
+
 /**
  * Resolves the tasks output directory path
  * @param {string} projectRoot - The project root directory

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

@@ -7,7 +7,8 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	getProjectRootFromSession,
+	withNormalizedProjectRoot
 } from './utils.js';
 import { addDependencyDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -35,28 +36,16 @@ export function registerAddDependencyTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(
 					`Adding dependency for task ${args.id} to depend on ${args.dependsOn}`
 				);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -92,6 +81,6 @@ export function registerAddDependencyTool(server) {
 				log.error(`Error in addDependency tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

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

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { addSubtaskDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -60,24 +60,15 @@ export function registerAddSubtaskTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -113,6 +104,6 @@ export function registerAddSubtaskTool(server) {
 				log.error(`Error in addSubtask tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

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

@@ -6,8 +6,8 @@
 import { z } from 'zod';
 import {
 	createErrorResponse,
-	getProjectRootFromSession,
-	handleApiResult
+	handleApiResult,
+	withNormalizedProjectRoot
 } from './utils.js';
 import { addTaskDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -63,26 +63,15 @@ export function registerAddTaskTool(server) {
 				.optional()
 				.describe('Whether to use research capabilities for task creation')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Starting add-task with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -92,12 +81,10 @@ export function registerAddTaskTool(server) {
 					);
 				}
 
-				// Call the direct function
+				// Call the direct functionP
 				const result = await addTaskDirect(
 					{
-						// Pass the explicitly resolved path
 						tasksJsonPath: tasksJsonPath,
-						// Pass other relevant args
 						prompt: args.prompt,
 						title: args.title,
 						description: args.description,
@@ -106,18 +93,17 @@ export function registerAddTaskTool(server) {
 						dependencies: args.dependencies,
 						priority: args.priority,
 						research: args.research,
-						projectRoot: rootFolder
+						projectRoot: args.projectRoot
 					},
 					log,
 					{ session }
 				);
 
-				// Return the result
 				return handleApiResult(result, log);
 			} catch (error) {
 				log.error(`Error in add-task tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/analyze.js

@@ -9,7 +9,7 @@ import fs from 'fs'; // Import fs for directory check/creation
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession // Assuming this is in './utils.js' relative to this file
+	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';
@@ -53,44 +53,34 @@ export function registerAnalyzeProjectComplexityTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		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)}`
 				);
 
-				// 1. Get Project Root (Mandatory for this tool)
-				const rootFolder = args.projectRoot;
-				if (!rootFolder || !path.isAbsolute(rootFolder)) {
-					log.error(
-						`${toolName}: projectRoot is required and must be absolute.`
-					);
-					return createErrorResponse(
-						'projectRoot is required and must be absolute.'
-					);
-				}
-				log.info(`${toolName}: Project root: ${rootFolder}`);
-
-				// 2. Resolve Paths relative to projectRoot
 				let tasksJsonPath;
 				try {
-					// Note: findTasksJsonPath expects 'file' relative to root, or absolute
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file }, // Pass root and optional relative file path
+						{ 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 '${rootFolder}': ${error.message}`
+						`Failed to find tasks.json within project root '${args.projectRoot}': ${error.message}`
 					);
 				}
 
 				const outputPath = args.output
-					? path.resolve(rootFolder, args.output) // Resolve relative output path
-					: path.resolve(rootFolder, 'scripts', 'task-complexity-report.json'); // Default location resolved relative to root
+					? path.resolve(args.projectRoot, args.output)
+					: path.resolve(
+							args.projectRoot,
+							'scripts',
+							'task-complexity-report.json'
+						);
 
 				log.info(`${toolName}: Report output path: ${outputPath}`);
 
@@ -113,26 +103,21 @@ export function registerAnalyzeProjectComplexityTool(server) {
 				// 3. Call Direct Function - Pass projectRoot in first arg object
 				const result = await analyzeTaskComplexityDirect(
 					{
-						// Pass resolved absolute paths and other args
 						tasksJsonPath: tasksJsonPath,
-						outputPath: outputPath, // Pass resolved absolute path
+						outputPath: outputPath,
 						threshold: args.threshold,
 						research: args.research,
-						projectRoot: rootFolder // <<< Pass projectRoot HERE
+						projectRoot: args.projectRoot
 					},
 					log,
-					{ session } // Pass context object with session
+					{ session }
 				);
 
 				// 4. Handle Result
 				log.info(
 					`${toolName}: Direct function result: success=${result.success}`
 				);
-				return handleApiResult(
-					result,
-					log,
-					'Error analyzing task complexity' // Consistent error prefix
-				);
+				return handleApiResult(result, log, 'Error analyzing task complexity');
 			} catch (error) {
 				log.error(
 					`Critical error in ${toolName} tool execute: ${error.message}`
@@ -141,6 +126,6 @@ export function registerAnalyzeProjectComplexityTool(server) {
 					`Internal tool error (${toolName}): ${error.message}`
 				);
 			}
-		}
+		})
 	});
 }

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

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { clearSubtasksDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -41,26 +41,15 @@ export function registerClearSubtasksTool(server) {
 				message: "Either 'id' or 'all' parameter must be provided",
 				path: ['id', 'all']
 			}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -72,14 +61,11 @@ export function registerClearSubtasksTool(server) {
 
 				const result = await clearSubtasksDirect(
 					{
-						// Pass the explicitly resolved path
 						tasksJsonPath: tasksJsonPath,
-						// Pass other relevant args
 						id: args.id,
 						all: args.all
 					},
 					log
-					// Remove context object as clearSubtasksDirect likely doesn't need session/reportProgress
 				);
 
 				if (result.success) {
@@ -93,6 +79,6 @@ export function registerClearSubtasksTool(server) {
 				log.error(`Error in clearSubtasks tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

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

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { complexityReportDirect } from '../core/task-master-core.js';
 import path from 'path';
@@ -31,34 +31,24 @@ export function registerComplexityReportTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(
 					`Getting complexity report with args: ${JSON.stringify(args)}`
 				);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to the complexity report file
-				// Default to scripts/task-complexity-report.json relative to root
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				const reportPath = args.file
-					? path.resolve(rootFolder, args.file)
-					: path.resolve(rootFolder, 'scripts', 'task-complexity-report.json');
+					? path.resolve(args.projectRoot, args.file)
+					: path.resolve(
+							args.projectRoot,
+							'scripts',
+							'task-complexity-report.json'
+						);
 
 				const result = await complexityReportDirect(
 					{
-						// Pass the explicitly resolved path
 						reportPath: reportPath
-						// No other args specific to this tool
 					},
 					log
 				);
@@ -84,6 +74,6 @@ export function registerComplexityReportTool(server) {
 					`Failed to retrieve complexity report: ${error.message}`
 				);
 			}
-		}
+		})
 	});
 }

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

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { expandAllTasksDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -59,25 +59,16 @@ export function registerExpandAllTool(server) {
 					'Absolute path to the project root directory (derived from session if possible)'
 				)
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(
 					`Tool expand_all execution started with args: ${JSON.stringify(args)}`
 				);
 
-				const rootFolder = getProjectRootFromSession(session, log);
-				if (!rootFolder) {
-					log.error('Could not determine project root from session.');
-					return createErrorResponse(
-						'Could not determine project root from session.'
-					);
-				}
-				log.info(`Project root determined: ${rootFolder}`);
-
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 					log.info(`Resolved tasks.json path: ${tasksJsonPath}`);
@@ -95,7 +86,7 @@ export function registerExpandAllTool(server) {
 						research: args.research,
 						prompt: args.prompt,
 						force: args.force,
-						projectRoot: rootFolder
+						projectRoot: args.projectRoot
 					},
 					log,
 					{ session }
@@ -113,6 +104,6 @@ export function registerExpandAllTool(server) {
 					`An unexpected error occurred: ${error.message}`
 				);
 			}
-		}
+		})
 	});
 }

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

@@ -4,10 +4,13 @@
  */
 
 import { z } from 'zod';
-import { handleApiResult, createErrorResponse } from './utils.js';
+import {
+	handleApiResult,
+	createErrorResponse,
+	withNormalizedProjectRoot
+} from './utils.js';
 import { expandTaskDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
-import path from 'path';
 
 /**
  * Register the expand-task tool with the MCP server
@@ -44,32 +47,21 @@ export function registerExpandTaskTool(server) {
 				.default(false)
 				.describe('Force expansion even if subtasks exist')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Starting expand-task with args: ${JSON.stringify(args)}`);
 
-				const rootFolder = args.projectRoot;
-				if (!rootFolder || !path.isAbsolute(rootFolder)) {
-					log.error(
-						`expand-task: projectRoot is required and must be absolute.`
-					);
-					return createErrorResponse(
-						'projectRoot is required and must be absolute.'
-					);
-				}
-
-				// Resolve the path to tasks.json using the utility
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
-					log.info(`expand-task: Resolved tasks path: ${tasksJsonPath}`);
 				} catch (error) {
-					log.error(`expand-task: Error finding tasks.json: ${error.message}`);
+					log.error(`Error finding tasks.json: ${error.message}`);
 					return createErrorResponse(
-						`Failed to find tasks.json within project root '${rootFolder}': ${error.message}`
+						`Failed to find tasks.json: ${error.message}`
 					);
 				}
 
@@ -81,24 +73,17 @@ export function registerExpandTaskTool(server) {
 						research: args.research,
 						prompt: args.prompt,
 						force: args.force,
-						projectRoot: rootFolder
+						projectRoot: args.projectRoot
 					},
 					log,
 					{ session }
 				);
 
-				log.info(
-					`expand-task: Direct function result: success=${result.success}`
-				);
 				return handleApiResult(result, log, 'Error expanding task');
 			} catch (error) {
-				log.error(
-					`Critical error in ${toolName} tool execute: ${error.message}`
-				);
-				return createErrorResponse(
-					`Internal tool error (${toolName}): ${error.message}`
-				);
+				log.error(`Error in expand-task tool: ${error.message}`);
+				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/fix-dependencies.js

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { fixDependenciesDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -26,24 +26,15 @@ export function registerFixDependenciesTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Fixing dependencies with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -71,6 +62,6 @@ export function registerFixDependenciesTool(server) {
 				log.error(`Error in fixDependencies tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/generate.js

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { generateTaskFilesDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -32,26 +32,15 @@ export function registerGenerateTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Generating task files with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -61,17 +50,14 @@ export function registerGenerateTool(server) {
 					);
 				}
 
-				// Determine output directory: use explicit arg or default to tasks.json directory
 				const outputDir = args.output
-					? path.resolve(rootFolder, args.output) // Resolve relative to root if needed
+					? path.resolve(args.projectRoot, args.output)
 					: path.dirname(tasksJsonPath);
 
 				const result = await generateTaskFilesDirect(
 					{
-						// Pass the explicitly resolved paths
 						tasksJsonPath: tasksJsonPath,
 						outputDir: outputDir
-						// No other args specific to this tool
 					},
 					log
 				);
@@ -89,6 +75,6 @@ export function registerGenerateTool(server) {
 				log.error(`Error in generate tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

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

@@ -7,10 +7,13 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { showTaskDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
+import {
+	findTasksJsonPath,
+	findComplexityReportPath
+} from '../core/utils/path-utils.js';
 
 /**
  * Custom processor function that removes allTasks from the response
@@ -21,8 +24,10 @@ function processTaskResponse(data) {
 	if (!data) return data;
 
 	// If we have the expected structure with task and allTasks
-	if (data.task) {
-		// Return only the task object, removing the allTasks array
+	if (typeof data === 'object' && data !== null && data.id && data.title) {
+		// If the data itself looks like the task object, return it
+		return data;
+	} else if (data.task) {
 		return data.task;
 	}
 
@@ -44,44 +49,39 @@ export function registerShowTaskTool(server) {
 				.string()
 				.optional()
 				.describe("Filter subtasks by status (e.g., 'pending', 'done')"),
-			file: z.string().optional().describe('Absolute path to the tasks file'),
+			file: z
+				.string()
+				.optional()
+				.describe('Path to the tasks file relative to project root'),
+			complexityReport: z
+				.string()
+				.optional()
+				.describe(
+					'Path to the complexity report file (relative to project root or absolute)'
+				),
 			projectRoot: z
 				.string()
-				.describe('The directory of the project. Must be an absolute path.')
+				.optional()
+				.describe(
+					'Absolute path to the project root directory (Optional, usually from session)'
+				)
 		}),
-		execute: async (args, { log, session }) => {
-			// Log the session right at the start of execute
-			log.info(
-				`Session object received in execute: ${JSON.stringify(session)}`
-			); // Use JSON.stringify for better visibility
+		execute: withNormalizedProjectRoot(async (args, { log }) => {
+			const { id, file, status, projectRoot } = args;
 
 			try {
 				log.info(
-					`Getting task details for ID: ${args.id}${args.status ? ` (filtering subtasks by status: ${args.status})` : ''}`
+					`Getting task details for ID: ${id}${status ? ` (filtering subtasks by status: ${status})` : ''} in root: ${projectRoot}`
 				);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				log.info(`Attempting to use project root: ${rootFolder}`); // Log the final resolved root
-
-				log.info(`Root folder: ${rootFolder}`); // Log the final resolved root
-
-				// Resolve the path to tasks.json
+				// Resolve the path to tasks.json using the NORMALIZED projectRoot from args
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: projectRoot, file: file },
 						log
 					);
+					log.info(`Resolved tasks path: ${tasksJsonPath}`);
 				} catch (error) {
 					log.error(`Error finding tasks.json: ${error.message}`);
 					return createErrorResponse(
@@ -89,13 +89,26 @@ export function registerShowTaskTool(server) {
 					);
 				}
 
-				log.info(`Attempting to use tasks file path: ${tasksJsonPath}`);
-
+				// Call the direct function, passing the normalized projectRoot
+				// Resolve the path to complexity report
+				let complexityReportPath;
+				try {
+					complexityReportPath = findComplexityReportPath(
+						projectRoot,
+						args.complexityReport,
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding complexity report: ${error.message}`);
+				}
 				const result = await showTaskDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
-						id: args.id,
-						status: args.status
+						reportPath: complexityReportPath,
+						// Pass other relevant args
+						id: id,
+						status: status,
+						projectRoot: projectRoot
 					},
 					log
 				);
@@ -108,7 +121,7 @@ export function registerShowTaskTool(server) {
 					log.error(`Failed to get task: ${result.error.message}`);
 				}
 
-				// Use our custom processor function to remove allTasks from the response
+				// Use our custom processor function
 				return handleApiResult(
 					result,
 					log,
@@ -116,9 +129,9 @@ export function registerShowTaskTool(server) {
 					processTaskResponse
 				);
 			} catch (error) {
-				log.error(`Error in get-task tool: ${error.message}\n${error.stack}`); // Add stack trace
+				log.error(`Error in get-task tool: ${error.message}\n${error.stack}`);
 				return createErrorResponse(`Failed to get task: ${error.message}`);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/get-tasks.js

@@ -7,10 +7,13 @@ import { z } from 'zod';
 import {
 	createErrorResponse,
 	handleApiResult,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { listTasksDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
+import {
+	findTasksJsonPath,
+	findComplexityReportPath
+} from '../core/utils/path-utils.js';
 
 /**
  * Register the getTasks tool with the MCP server
@@ -38,45 +41,51 @@ export function registerListTasksTool(server) {
 				.describe(
 					'Path to the tasks file (relative to project root or absolute)'
 				),
+			complexityReport: z
+				.string()
+				.optional()
+				.describe(
+					'Path to the complexity report file (relative to project root or absolute)'
+				),
 			projectRoot: z
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Getting tasks with filters: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
 					log.error(`Error finding tasks.json: ${error.message}`);
-					// Use the error message from findTasksJsonPath for better context
 					return createErrorResponse(
 						`Failed to find tasks.json: ${error.message}`
 					);
 				}
 
+				// Resolve the path to complexity report
+				let complexityReportPath;
+				try {
+					complexityReportPath = findComplexityReportPath(
+						args.projectRoot,
+						args.complexityReport,
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding complexity report: ${error.message}`);
+				}
 				const result = await listTasksDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
 						status: args.status,
-						withSubtasks: args.withSubtasks
+						withSubtasks: args.withSubtasks,
+						reportPath: complexityReportPath
 					},
 					log
 				);
@@ -89,7 +98,7 @@ export function registerListTasksTool(server) {
 				log.error(`Error getting tasks: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }
 

mcp-server/src/tools/initialize-project.js

@@ -1,5 +1,9 @@
 import { z } from 'zod';
-import { createErrorResponse, handleApiResult } from './utils.js';
+import {
+	createErrorResponse,
+	handleApiResult,
+	withNormalizedProjectRoot
+} from './utils.js';
 import { initializeProjectDirect } from '../core/task-master-core.js';
 
 export function registerInitializeProjectTool(server) {
@@ -33,19 +37,10 @@ export function registerInitializeProjectTool(server) {
 					'The root directory for the project. ALWAYS SET THIS TO THE PROJECT ROOT DIRECTORY. IF NOT SET, THE TOOL WILL NOT WORK.'
 				)
 		}),
-		execute: async (args, context) => {
+		execute: withNormalizedProjectRoot(async (args, context) => {
 			const { log } = context;
 			const session = context.session;
 
-			log.info(
-				'>>> Full Context Received by Tool:',
-				JSON.stringify(context, null, 2)
-			);
-			log.info(`Context received in tool function: ${context}`);
-			log.info(
-				`Session received in tool function: ${session ? session : 'undefined'}`
-			);
-
 			try {
 				log.info(
 					`Executing initialize_project tool with args: ${JSON.stringify(args)}`
@@ -59,6 +54,6 @@ export function registerInitializeProjectTool(server) {
 				log.error(errorMessage, error);
 				return createErrorResponse(errorMessage, { details: error.stack });
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/models.js

@@ -5,9 +5,9 @@
 
 import { z } from 'zod';
 import {
-	getProjectRootFromSession,
 	handleApiResult,
-	createErrorResponse
+	createErrorResponse,
+	withNormalizedProjectRoot
 } from './utils.js';
 import { modelsDirect } from '../core/task-master-core.js';
 
@@ -42,7 +42,9 @@ export function registerModelsTool(server) {
 			listAvailableModels: z
 				.boolean()
 				.optional()
-				.describe('List all available models not currently in use.'),
+				.describe(
+					'List all available models not currently in use. Input/output costs values are in dollars (3 is $3.00).'
+				),
 			projectRoot: z
 				.string()
 				.optional()
@@ -56,34 +58,22 @@ export function registerModelsTool(server) {
 				.optional()
 				.describe('Indicates the set model ID is a custom Ollama model.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Starting models tool with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Call the direct function
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				const result = await modelsDirect(
-					{ ...args, projectRoot: rootFolder },
+					{ ...args, projectRoot: args.projectRoot },
 					log,
 					{ session }
 				);
 
-				// Handle and return the result
 				return handleApiResult(result, log);
 			} catch (error) {
 				log.error(`Error in models tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

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

@@ -7,10 +7,13 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { nextTaskDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
+import {
+	findTasksJsonPath,
+	findComplexityReportPath
+} from '../core/utils/path-utils.js';
 
 /**
  * Register the next-task tool with the MCP server
@@ -23,30 +26,25 @@ export function registerNextTaskTool(server) {
 			'Find the next task to work on based on dependencies and status',
 		parameters: z.object({
 			file: z.string().optional().describe('Absolute path to the tasks file'),
+			complexityReport: z
+				.string()
+				.optional()
+				.describe(
+					'Path to the complexity report file (relative to project root or absolute)'
+				),
 			projectRoot: z
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Finding next task with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -56,11 +54,21 @@ export function registerNextTaskTool(server) {
 					);
 				}
 
+				// Resolve the path to complexity report
+				let complexityReportPath;
+				try {
+					complexityReportPath = findComplexityReportPath(
+						args.projectRoot,
+						args.complexityReport,
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding complexity report: ${error.message}`);
+				}
 				const result = await nextTaskDirect(
 					{
-						// Pass the explicitly resolved path
-						tasksJsonPath: tasksJsonPath
-						// No other args specific to this tool
+						tasksJsonPath: tasksJsonPath,
+						reportPath: complexityReportPath
 					},
 					log
 				);
@@ -80,6 +88,6 @@ export function registerNextTaskTool(server) {
 				log.error(`Error in nextTask tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/parse-prd.js

@@ -5,7 +5,11 @@
 
 import { z } from 'zod';
 import path from 'path';
-import { handleApiResult, createErrorResponse } from './utils.js';
+import {
+	handleApiResult,
+	createErrorResponse,
+	withNormalizedProjectRoot
+} from './utils.js';
 import { parsePRDDirect } from '../core/task-master-core.js';
 
 /**
@@ -49,42 +53,27 @@ export function registerParsePRDTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			const toolName = 'parse_prd';
 			try {
 				log.info(
 					`Executing ${toolName} tool with args: ${JSON.stringify(args)}`
 				);
 
-				// 1. Get Project Root
-				const rootFolder = args.projectRoot;
-				if (!rootFolder || !path.isAbsolute(rootFolder)) {
-					log.error(
-						`${toolName}: projectRoot is required and must be absolute.`
-					);
-					return createErrorResponse(
-						'projectRoot is required and must be absolute.'
-					);
-				}
-				log.info(`${toolName}: Project root: ${rootFolder}`);
-
-				// 2. Call Direct Function - Pass relevant args including projectRoot
-				// Path resolution (input/output) is handled within the direct function now
+				// Call Direct Function - Pass relevant args including projectRoot
 				const result = await parsePRDDirect(
 					{
-						// Pass args directly needed by the direct function
-						input: args.input, // Pass relative or absolute path
-						output: args.output, // Pass relative or absolute path
-						numTasks: args.numTasks, // Pass number (direct func handles default)
+						input: args.input,
+						output: args.output,
+						numTasks: args.numTasks,
 						force: args.force,
 						append: args.append,
-						projectRoot: rootFolder
+						projectRoot: args.projectRoot
 					},
 					log,
-					{ session } // Pass context object with session
+					{ session }
 				);
 
-				// 3. Handle Result
 				log.info(
 					`${toolName}: Direct function result: success=${result.success}`
 				);
@@ -97,6 +86,6 @@ export function registerParsePRDTool(server) {
 					`Internal tool error (${toolName}): ${error.message}`
 				);
 			}
-		}
+		})
 	});
 }

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

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { removeDependencyDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -33,28 +33,17 @@ export function registerRemoveDependencyTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(
 					`Removing dependency for task ${args.id} from ${args.dependsOn} with args: ${JSON.stringify(args)}`
 				);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -66,9 +55,7 @@ export function registerRemoveDependencyTool(server) {
 
 				const result = await removeDependencyDirect(
 					{
-						// Pass the explicitly resolved path
 						tasksJsonPath: tasksJsonPath,
-						// Pass other relevant args
 						id: args.id,
 						dependsOn: args.dependsOn
 					},
@@ -86,6 +73,6 @@ export function registerRemoveDependencyTool(server) {
 				log.error(`Error in removeDependency tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

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

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { removeSubtaskDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -46,26 +46,15 @@ export function registerRemoveSubtaskTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log }) => {
 			try {
 				log.info(`Removing subtask with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -77,9 +66,7 @@ export function registerRemoveSubtaskTool(server) {
 
 				const result = await removeSubtaskDirect(
 					{
-						// Pass the explicitly resolved path
 						tasksJsonPath: tasksJsonPath,
-						// Pass other relevant args
 						id: args.id,
 						convert: args.convert,
 						skipGenerate: args.skipGenerate
@@ -98,6 +85,6 @@ export function registerRemoveSubtaskTool(server) {
 				log.error(`Error in removeSubtask tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

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

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { removeTaskDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -35,28 +35,15 @@ export function registerRemoveTaskTool(server) {
 				.optional()
 				.describe('Whether to skip confirmation prompt (default: false)')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log }) => {
 			try {
 				log.info(`Removing task(s) with ID(s): ${args.id}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				log.info(`Using project root: ${rootFolder}`);
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -68,7 +55,6 @@ export function registerRemoveTaskTool(server) {
 
 				log.info(`Using tasks file path: ${tasksJsonPath}`);
 
-				// Assume client has already handled confirmation if needed
 				const result = await removeTaskDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
@@ -88,6 +74,6 @@ export function registerRemoveTaskTool(server) {
 				log.error(`Error in remove-task tool: ${error.message}`);
 				return createErrorResponse(`Failed to remove task: ${error.message}`);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/set-task-status.js

@@ -7,10 +7,11 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { setTaskStatusDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
+import { TASK_STATUS_OPTIONS } from '../../../src/constants/task-status.js';
 
 /**
  * Register the setTaskStatus tool with the MCP server
@@ -27,7 +28,7 @@ export function registerSetTaskStatusTool(server) {
 					"Task ID or subtask ID (e.g., '15', '15.2'). Can be comma-separated to update multiple tasks/subtasks at once."
 				),
 			status: z
-				.string()
+				.enum(TASK_STATUS_OPTIONS)
 				.describe(
 					"New status to set (e.g., 'pending', 'done', 'in-progress', 'review', 'deferred', 'cancelled'."
 				),
@@ -36,26 +37,15 @@ export function registerSetTaskStatusTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log }) => {
 			try {
 				log.info(`Setting status of task(s) ${args.id} to: ${args.status}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				// Ensure project root was determined
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
-				// Resolve the path to tasks.json
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -65,19 +55,15 @@ export function registerSetTaskStatusTool(server) {
 					);
 				}
 
-				// Call the direct function with the resolved path
 				const result = await setTaskStatusDirect(
 					{
-						// Pass the explicitly resolved path
 						tasksJsonPath: tasksJsonPath,
-						// Pass other relevant args
 						id: args.id,
 						status: args.status
 					},
 					log
 				);
 
-				// Log the result
 				if (result.success) {
 					log.info(
 						`Successfully updated status for task(s) ${args.id} to "${args.status}": ${result.data.message}`
@@ -88,7 +74,6 @@ export function registerSetTaskStatusTool(server) {
 					);
 				}
 
-				// Format and return the result
 				return handleApiResult(result, log, 'Error setting task status');
 			} catch (error) {
 				log.error(`Error in setTaskStatus tool: ${error.message}`);
@@ -96,6 +81,6 @@ export function registerSetTaskStatusTool(server) {
 					`Error setting task status: ${error.message}`
 				);
 			}
-		}
+		})
 	});
 }

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

@@ -4,10 +4,13 @@
  */
 
 import { z } from 'zod';
-import { handleApiResult, createErrorResponse } from './utils.js';
+import {
+	handleApiResult,
+	createErrorResponse,
+	withNormalizedProjectRoot
+} from './utils.js';
 import { updateSubtaskByIdDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
-import path from 'path';
 
 /**
  * Register the update-subtask tool with the MCP server
@@ -34,45 +37,31 @@ export function registerUpdateSubtaskTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			const toolName = 'update_subtask';
 			try {
 				log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
 
-				// 1. Get Project Root
-				const rootFolder = args.projectRoot;
-				if (!rootFolder || !path.isAbsolute(rootFolder)) {
-					log.error(
-						`${toolName}: projectRoot is required and must be absolute.`
-					);
-					return createErrorResponse(
-						'projectRoot is required and must be absolute.'
-					);
-				}
-				log.info(`${toolName}: Project root: ${rootFolder}`);
-
-				// 2. Resolve Tasks Path
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
 					log.error(`${toolName}: Error finding tasks.json: ${error.message}`);
 					return createErrorResponse(
-						`Failed to find tasks.json within project root '${rootFolder}': ${error.message}`
+						`Failed to find tasks.json: ${error.message}`
 					);
 				}
 
-				// 3. Call Direct Function - Include projectRoot
 				const result = await updateSubtaskByIdDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
 						id: args.id,
 						prompt: args.prompt,
 						research: args.research,
-						projectRoot: rootFolder
+						projectRoot: args.projectRoot
 					},
 					log,
 					{ session }
@@ -95,6 +84,6 @@ export function registerUpdateSubtaskTool(server) {
 					`Internal tool error (${toolName}): ${error.message}`
 				);
 			}
-		}
+		})
 	});
 }

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

@@ -4,11 +4,10 @@
  */
 
 import { z } from 'zod';
-import path from 'path'; // Import path
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { updateTaskByIdDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -40,58 +39,44 @@ export function registerUpdateTaskTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			const toolName = 'update_task';
 			try {
 				log.info(
 					`Executing ${toolName} tool with args: ${JSON.stringify(args)}`
 				);
 
-				// 1. Get Project Root
-				const rootFolder = args.projectRoot;
-				if (!rootFolder || !path.isAbsolute(rootFolder)) {
-					log.error(
-						`${toolName}: projectRoot is required and must be absolute.`
-					);
-					return createErrorResponse(
-						'projectRoot is required and must be absolute.'
-					);
-				}
-				log.info(`${toolName}: Project root: ${rootFolder}`);
-
-				// 2. Resolve Tasks Path
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file }, // Pass root and optional relative file
+						{ 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 '${rootFolder}': ${error.message}`
+						`Failed to find tasks.json: ${error.message}`
 					);
 				}
 
 				// 3. Call Direct Function - Include projectRoot
 				const result = await updateTaskByIdDirect(
 					{
-						tasksJsonPath: tasksJsonPath, // Pass resolved path
+						tasksJsonPath: tasksJsonPath,
 						id: args.id,
 						prompt: args.prompt,
 						research: args.research,
-						projectRoot: rootFolder // <<< Pass projectRoot HERE
+						projectRoot: args.projectRoot
 					},
 					log,
-					{ session } // Pass context with session
+					{ session }
 				);
 
 				// 4. Handle Result
 				log.info(
 					`${toolName}: Direct function result: success=${result.success}`
 				);
-				// Pass the actual data from the result (contains updated task or message)
 				return handleApiResult(result, log, 'Error updating task');
 			} catch (error) {
 				log.error(
@@ -101,6 +86,6 @@ export function registerUpdateTaskTool(server) {
 					`Internal tool error (${toolName}): ${error.message}`
 				);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/update.js

@@ -4,10 +4,13 @@
  */
 
 import { z } from 'zod';
-import { handleApiResult, createErrorResponse } from './utils.js';
+import {
+	handleApiResult,
+	createErrorResponse,
+	withNormalizedProjectRoot
+} from './utils.js';
 import { updateTasksDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
-import path from 'path';
 
 /**
  * Register the update tool with the MCP server
@@ -31,59 +34,61 @@ export function registerUpdateTool(server) {
 				.boolean()
 				.optional()
 				.describe('Use Perplexity AI for research-backed updates'),
-			file: z.string().optional().describe('Absolute path to the tasks file'),
+			file: z
+				.string()
+				.optional()
+				.describe('Path to the tasks file relative to project root'),
 			projectRoot: z
 				.string()
-				.describe('The directory of the project. Must be an absolute path.')
+				.optional()
+				.describe(
+					'The directory of the project. (Optional, usually from session)'
+				)
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+			const toolName = 'update';
+			const { from, prompt, research, file, projectRoot } = args;
+
 			try {
-				log.info(`Executing update tool with args: ${JSON.stringify(args)}`);
+				log.info(
+					`Executing ${toolName} tool with normalized root: ${projectRoot}`
+				);
 
-				// 1. Get Project Root
-				const rootFolder = args.projectRoot;
-				if (!rootFolder || !path.isAbsolute(rootFolder)) {
-					return createErrorResponse(
-						'projectRoot is required and must be absolute.'
-					);
-				}
-				log.info(`Project root: ${rootFolder}`);
-
-				// 2. Resolve Path
 				let tasksJsonPath;
 				try {
-					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
-						log
-					);
-					log.info(`Resolved tasks path: ${tasksJsonPath}`);
+					tasksJsonPath = findTasksJsonPath({ projectRoot, file }, log);
+					log.info(`${toolName}: Resolved tasks path: ${tasksJsonPath}`);
 				} catch (error) {
-					log.error(`Error finding tasks.json: ${error.message}`);
+					log.error(`${toolName}: Error finding tasks.json: ${error.message}`);
 					return createErrorResponse(
-						`Failed to find tasks.json: ${error.message}`
+						`Failed to find tasks.json within project root '${projectRoot}': ${error.message}`
 					);
 				}
 
-				// 3. Call Direct Function
 				const result = await updateTasksDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
-						from: args.from,
-						prompt: args.prompt,
-						research: args.research,
-						projectRoot: rootFolder
+						from: from,
+						prompt: prompt,
+						research: research,
+						projectRoot: projectRoot
 					},
 					log,
 					{ session }
 				);
 
-				// 4. Handle Result
-				log.info(`updateTasksDirect result: success=${result.success}`);
+				log.info(
+					`${toolName}: Direct function result: success=${result.success}`
+				);
 				return handleApiResult(result, log, 'Error updating tasks');
 			} catch (error) {
-				log.error(`Critical error in update tool execute: ${error.message}`);
-				return createErrorResponse(`Internal tool error: ${error.message}`);
+				log.error(
+					`Critical error in ${toolName} tool execute: ${error.message}`
+				);
+				return createErrorResponse(
+					`Internal tool error (${toolName}): ${error.message}`
+				);
 			}
-		}
+		})
 	});
 }

mcp-server/src/tools/utils.js

@@ -83,10 +83,10 @@ function getProjectRoot(projectRootRaw, log) {
 }
 
 /**
- * Extracts the project root path from the FastMCP session object.
- * @param {Object} session - The FastMCP session object.
- * @param {Object} log - Logger object.
- * @returns {string|null} - The absolute path to the project root, or null if not found.
+ * Extracts and normalizes the project root path from the MCP session object.
+ * @param {Object} session - The MCP session object.
+ * @param {Object} log - The MCP logger object.
+ * @returns {string|null} - The normalized absolute project root path or null if not found/invalid.
  */
 function getProjectRootFromSession(session, log) {
 	try {
@@ -107,68 +107,87 @@ function getProjectRootFromSession(session, log) {
 			})}`
 		);
 
-		// ALWAYS ensure we return a valid path for project root
+		let rawRootPath = null;
+		let decodedPath = null;
+		let finalPath = null;
+
+		// Check primary location
+		if (session?.roots?.[0]?.uri) {
+			rawRootPath = session.roots[0].uri;
+			log.info(`Found raw root URI in session.roots[0].uri: ${rawRootPath}`);
+		}
+		// Check alternate location
+		else if (session?.roots?.roots?.[0]?.uri) {
+			rawRootPath = session.roots.roots[0].uri;
+			log.info(
+				`Found raw root URI in session.roots.roots[0].uri: ${rawRootPath}`
+			);
+		}
+
+		if (rawRootPath) {
+			// Decode URI and strip file:// protocol
+			decodedPath = rawRootPath.startsWith('file://')
+				? decodeURIComponent(rawRootPath.slice(7))
+				: rawRootPath; // Assume non-file URI is already decoded? Or decode anyway? Let's decode.
+			if (!rawRootPath.startsWith('file://')) {
+				decodedPath = decodeURIComponent(rawRootPath); // Decode even if no file://
+			}
+
+			// Handle potential Windows drive prefix after stripping protocol (e.g., /C:/...)
+			if (
+				decodedPath.startsWith('/') &&
+				/[A-Za-z]:/.test(decodedPath.substring(1, 3))
+			) {
+				decodedPath = decodedPath.substring(1); // Remove leading slash if it's like /C:/...
+			}
+
+			log.info(`Decoded path: ${decodedPath}`);
+
+			// Normalize slashes and resolve
+			const normalizedSlashes = decodedPath.replace(/\\/g, '/');
+			finalPath = path.resolve(normalizedSlashes); // Resolve to absolute path for current OS
+
+			log.info(`Normalized and resolved session path: ${finalPath}`);
+			return finalPath;
+		}
+
+		// Fallback Logic (remains the same)
+		log.warn('No project root URI found in session. Attempting fallbacks...');
 		const cwd = process.cwd();
 
-		// If we have a session with roots array
-		if (session?.roots?.[0]?.uri) {
-			const rootUri = session.roots[0].uri;
-			log.info(`Found rootUri in session.roots[0].uri: ${rootUri}`);
-			const rootPath = rootUri.startsWith('file://')
-				? decodeURIComponent(rootUri.slice(7))
-				: rootUri;
-			log.info(`Decoded rootPath: ${rootPath}`);
-			return rootPath;
-		}
-
-		// If we have a session with roots.roots array (different structure)
-		if (session?.roots?.roots?.[0]?.uri) {
-			const rootUri = session.roots.roots[0].uri;
-			log.info(`Found rootUri in session.roots.roots[0].uri: ${rootUri}`);
-			const rootPath = rootUri.startsWith('file://')
-				? decodeURIComponent(rootUri.slice(7))
-				: rootUri;
-			log.info(`Decoded rootPath: ${rootPath}`);
-			return rootPath;
-		}
-
-		// Get the server's location and try to find project root -- this is a fallback necessary in Cursor IDE
-		const serverPath = process.argv[1]; // This should be the path to server.js, which is in mcp-server/
+		// Fallback 1: Use server path deduction (Cursor IDE)
+		const serverPath = process.argv[1];
 		if (serverPath && serverPath.includes('mcp-server')) {
-			// Find the mcp-server directory first
 			const mcpServerIndex = serverPath.indexOf('mcp-server');
 			if (mcpServerIndex !== -1) {
-				// Get the path up to mcp-server, which should be the project root
-				const projectRoot = serverPath.substring(0, mcpServerIndex - 1); // -1 to remove trailing slash
+				const projectRoot = path.dirname(
+					serverPath.substring(0, mcpServerIndex)
+				); // Go up one level
 
-				// Verify this looks like our project root by checking for key files/directories
 				if (
 					fs.existsSync(path.join(projectRoot, '.cursor')) ||
 					fs.existsSync(path.join(projectRoot, 'mcp-server')) ||
 					fs.existsSync(path.join(projectRoot, 'package.json'))
 				) {
-					log.info(`Found project root from server path: ${projectRoot}`);
-					return projectRoot;
+					log.info(
+						`Using project root derived from server path: ${projectRoot}`
+					);
+					return projectRoot; // Already absolute
 				}
 			}
 		}
 
-		// ALWAYS ensure we return a valid path as a last resort
+		// Fallback 2: Use CWD
 		log.info(`Using current working directory as ultimate fallback: ${cwd}`);
-		return cwd;
+		return cwd; // Already absolute
 	} catch (e) {
-		// If we have a server path, use it as a basis for project root
-		const serverPath = process.argv[1];
-		if (serverPath && serverPath.includes('mcp-server')) {
-			const mcpServerIndex = serverPath.indexOf('mcp-server');
-			return mcpServerIndex !== -1
-				? serverPath.substring(0, mcpServerIndex - 1)
-				: process.cwd();
-		}
-
-		// Only use cwd if it's not "/"
+		log.error(`Error in getProjectRootFromSession: ${e.message}`);
+		// Attempt final fallback to CWD on error
 		const cwd = process.cwd();
-		return cwd !== '/' ? cwd : '/';
+		log.warn(
+			`Returning CWD (${cwd}) due to error during session root processing.`
+		);
+		return cwd;
 	}
 }
 
@@ -474,6 +493,148 @@ function createLogWrapper(log) {
 	};
 }
 
+/**
+ * Resolves and normalizes a project root path from various formats.
+ * Handles URI encoding, Windows paths, and file protocols.
+ * @param {string | undefined | null} rawPath - The raw project root path.
+ * @param {object} [log] - Optional logger object.
+ * @returns {string | null} Normalized absolute path or null if input is invalid/empty.
+ */
+function normalizeProjectRoot(rawPath, log) {
+	if (!rawPath) return null;
+	try {
+		let pathString = Array.isArray(rawPath) ? rawPath[0] : String(rawPath);
+		if (!pathString) return null;
+
+		// 1. Decode URI Encoding
+		// Use try-catch for decoding as malformed URIs can throw
+		try {
+			pathString = decodeURIComponent(pathString);
+		} catch (decodeError) {
+			if (log)
+				log.warn(
+					`Could not decode URI component for path "${rawPath}": ${decodeError.message}. Proceeding with raw string.`
+				);
+			// Proceed with the original string if decoding fails
+			pathString = Array.isArray(rawPath) ? rawPath[0] : String(rawPath);
+		}
+
+		// 2. Strip file:// prefix (handle 2 or 3 slashes)
+		if (pathString.startsWith('file:///')) {
+			pathString = pathString.slice(7); // Slice 7 for file:///, may leave leading / on Windows
+		} else if (pathString.startsWith('file://')) {
+			pathString = pathString.slice(7); // Slice 7 for file://
+		}
+
+		// 3. Handle potential Windows leading slash after stripping prefix (e.g., /C:/...)
+		// This checks if it starts with / followed by a drive letter C: D: etc.
+		if (
+			pathString.startsWith('/') &&
+			/[A-Za-z]:/.test(pathString.substring(1, 3))
+		) {
+			pathString = pathString.substring(1); // Remove the leading slash
+		}
+
+		// 4. Normalize backslashes to forward slashes
+		pathString = pathString.replace(/\\/g, '/');
+
+		// 5. Resolve to absolute path using server's OS convention
+		const resolvedPath = path.resolve(pathString);
+		return resolvedPath;
+	} catch (error) {
+		if (log) {
+			log.error(
+				`Error normalizing project root path "${rawPath}": ${error.message}`
+			);
+		}
+		return null; // Return null on error
+	}
+}
+
+/**
+ * Extracts the raw project root path from the session (without normalization).
+ * Used as a fallback within the HOF.
+ * @param {Object} session - The MCP session object.
+ * @param {Object} log - The MCP logger object.
+ * @returns {string|null} The raw path string or null.
+ */
+function getRawProjectRootFromSession(session, log) {
+	try {
+		// Check primary location
+		if (session?.roots?.[0]?.uri) {
+			return session.roots[0].uri;
+		}
+		// Check alternate location
+		else if (session?.roots?.roots?.[0]?.uri) {
+			return session.roots.roots[0].uri;
+		}
+		return null; // Not found in expected session locations
+	} catch (e) {
+		log.error(`Error accessing session roots: ${e.message}`);
+		return null;
+	}
+}
+
+/**
+ * Higher-order function to wrap MCP tool execute methods.
+ * Ensures args.projectRoot is present and normalized before execution.
+ * @param {Function} executeFn - The original async execute(args, context) function.
+ * @returns {Function} The wrapped async execute function.
+ */
+function withNormalizedProjectRoot(executeFn) {
+	return async (args, context) => {
+		const { log, session } = context;
+		let normalizedRoot = null;
+		let rootSource = 'unknown';
+
+		try {
+			// Determine raw root: prioritize args, then session
+			let rawRoot = args.projectRoot;
+			if (!rawRoot) {
+				rawRoot = getRawProjectRootFromSession(session, log);
+				rootSource = 'session';
+			} else {
+				rootSource = 'args';
+			}
+
+			if (!rawRoot) {
+				log.error('Could not determine project root from args or session.');
+				return createErrorResponse(
+					'Could not determine project root. Please provide projectRoot argument or ensure session contains root info.'
+				);
+			}
+
+			// Normalize the determined raw root
+			normalizedRoot = normalizeProjectRoot(rawRoot, log);
+
+			if (!normalizedRoot) {
+				log.error(
+					`Failed to normalize project root obtained from ${rootSource}: ${rawRoot}`
+				);
+				return createErrorResponse(
+					`Invalid project root provided or derived from ${rootSource}: ${rawRoot}`
+				);
+			}
+
+			// Inject the normalized root back into args
+			const updatedArgs = { ...args, projectRoot: normalizedRoot };
+
+			// Execute the original function with normalized root in args
+			return await executeFn(updatedArgs, context);
+		} catch (error) {
+			log.error(
+				`Error within withNormalizedProjectRoot HOF (Normalized Root: ${normalizedRoot}): ${error.message}`
+			);
+			// Add stack trace if available and debug enabled
+			if (error.stack && log.debug) {
+				log.debug(error.stack);
+			}
+			// Return a generic error or re-throw depending on desired behavior
+			return createErrorResponse(`Operation failed: ${error.message}`);
+		}
+	};
+}
+
 // Ensure all functions are exported
 export {
 	getProjectRoot,
@@ -484,5 +645,8 @@ export {
 	processMCPResponseData,
 	createContentResponse,
 	createErrorResponse,
-	createLogWrapper
+	createLogWrapper,
+	normalizeProjectRoot,
+	getRawProjectRootFromSession,
+	withNormalizedProjectRoot
 };

mcp-server/src/tools/validate-dependencies.js

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession
+	withNormalizedProjectRoot
 } from './utils.js';
 import { validateDependenciesDirect } from '../core/task-master-core.js';
 import { findTasksJsonPath } from '../core/utils/path-utils.js';
@@ -27,24 +27,15 @@ export function registerValidateDependenciesTool(server) {
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session }) => {
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
 			try {
 				log.info(`Validating dependencies with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
-				const rootFolder =
-					args.projectRoot || getProjectRootFromSession(session, log);
-
-				if (!rootFolder) {
-					return createErrorResponse(
-						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
-					);
-				}
-
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
 				let tasksJsonPath;
 				try {
 					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: rootFolder, file: args.file },
+						{ projectRoot: args.projectRoot, file: args.file },
 						log
 					);
 				} catch (error) {
@@ -74,6 +65,6 @@ export function registerValidateDependenciesTool(server) {
 				log.error(`Error in validateDependencies tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		}
+		})
 	});
 }

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "task-master-ai",
-	"version": "0.12.1",
+	"version": "0.13.2",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "task-master-ai",
-			"version": "0.12.1",
+			"version": "0.13.2",
 			"license": "MIT WITH Commons-Clause",
 			"dependencies": {
 				"@ai-sdk/anthropic": "^1.2.10",
@@ -19,6 +19,9 @@
 				"@anthropic-ai/sdk": "^0.39.0",
 				"@openrouter/ai-sdk-provider": "^0.4.5",
 				"ai": "^4.3.10",
+				"boxen": "^8.0.1",
+				"chalk": "^5.4.1",
+				"cli-table3": "^0.6.5",
 				"commander": "^11.1.0",
 				"cors": "^2.8.5",
 				"dotenv": "^16.3.1",
@@ -34,7 +37,8 @@
 				"ollama-ai-provider": "^1.2.0",
 				"openai": "^4.89.0",
 				"ora": "^8.2.0",
-				"uuid": "^11.1.0"
+				"uuid": "^11.1.0",
+				"zod": "^3.23.8"
 			},
 			"bin": {
 				"task-master": "bin/task-master.js",
@@ -45,9 +49,6 @@
 				"@changesets/changelog-github": "^0.5.1",
 				"@changesets/cli": "^2.28.1",
 				"@types/jest": "^29.5.14",
-				"boxen": "^8.0.1",
-				"chalk": "^5.4.1",
-				"cli-table3": "^0.6.5",
 				"execa": "^8.0.1",
 				"ink": "^5.0.1",
 				"jest": "^29.7.0",
@@ -57,8 +58,7 @@
 				"prettier": "^3.5.3",
 				"react": "^18.3.1",
 				"supertest": "^7.1.0",
-				"tsx": "^4.16.2",
-				"zod": "^3.23.8"
+				"tsx": "^4.16.2"
 			},
 			"engines": {
 				"node": ">=14.0.0"
@@ -1238,7 +1238,6 @@
 			"version": "1.5.0",
 			"resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
 			"integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==",
-			"dev": true,
 			"license": "MIT",
 			"optional": true,
 			"engines": {
@@ -3307,7 +3306,6 @@
 			"version": "3.0.1",
 			"resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz",
 			"integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==",
-			"dev": true,
 			"license": "ISC",
 			"dependencies": {
 				"string-width": "^4.1.0"
@@ -3317,7 +3315,6 @@
 			"version": "5.0.1",
 			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
 			"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=8"
@@ -3327,14 +3324,12 @@
 			"version": "8.0.0",
 			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
 			"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-			"dev": true,
 			"license": "MIT"
 		},
 		"node_modules/ansi-align/node_modules/string-width": {
 			"version": "4.2.3",
 			"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
 			"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"emoji-regex": "^8.0.0",
@@ -3349,7 +3344,6 @@
 			"version": "6.0.1",
 			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
 			"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"ansi-regex": "^5.0.1"
@@ -3699,7 +3693,6 @@
 			"version": "8.0.1",
 			"resolved": "https://registry.npmjs.org/boxen/-/boxen-8.0.1.tgz",
 			"integrity": "sha512-F3PH5k5juxom4xktynS7MoFY+NUWH5LC4CnH11YB8NPew+HLpmBLCybSAEyb2F+4pRXhuhWqFesoQd6DAyc2hw==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"ansi-align": "^3.0.1",
@@ -3850,7 +3843,6 @@
 			"version": "8.0.0",
 			"resolved": "https://registry.npmjs.org/camelcase/-/camelcase-8.0.0.tgz",
 			"integrity": "sha512-8WB3Jcas3swSvjIeA2yvCJ+Miyz5l1ZmB6HFb9R1317dt9LCQoswg/BGrmAmkWVEszSrrg4RwmO46qIm2OEnSA==",
-			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=16"
@@ -3935,7 +3927,6 @@
 			"version": "3.0.0",
 			"resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz",
 			"integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==",
-			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=10"
@@ -3975,7 +3966,6 @@
 			"version": "0.6.5",
 			"resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.5.tgz",
 			"integrity": "sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"string-width": "^4.2.0"
@@ -3991,7 +3981,6 @@
 			"version": "5.0.1",
 			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
 			"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=8"
@@ -4001,14 +3990,12 @@
 			"version": "8.0.0",
 			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
 			"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-			"dev": true,
 			"license": "MIT"
 		},
 		"node_modules/cli-table3/node_modules/string-width": {
 			"version": "4.2.3",
 			"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
 			"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"emoji-regex": "^8.0.0",
@@ -4023,7 +4010,6 @@
 			"version": "6.0.1",
 			"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
 			"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"ansi-regex": "^5.0.1"
@@ -9488,7 +9474,6 @@
 			"version": "4.37.0",
 			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.37.0.tgz",
 			"integrity": "sha512-S/5/0kFftkq27FPNye0XM1e2NsnoD/3FS+pBmbjmmtLT6I+i344KoOf7pvXreaFsDamWeaJX55nczA1m5PsBDg==",
-			"dev": true,
 			"license": "(MIT OR CC0-1.0)",
 			"engines": {
 				"node": ">=16"
@@ -9698,7 +9683,6 @@
 			"version": "5.0.0",
 			"resolved": "https://registry.npmjs.org/widest-line/-/widest-line-5.0.0.tgz",
 			"integrity": "sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"string-width": "^7.0.0"
@@ -9714,7 +9698,6 @@
 			"version": "9.0.0",
 			"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.0.tgz",
 			"integrity": "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==",
-			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"ansi-styles": "^6.2.1",
@@ -9732,7 +9715,6 @@
 			"version": "6.2.1",
 			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
 			"integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
-			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=12"

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "task-master-ai",
-	"version": "0.12.1",
+	"version": "0.13.2",
 	"description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
 	"main": "index.js",
 	"type": "module",
@@ -64,7 +64,11 @@
 		"ollama-ai-provider": "^1.2.0",
 		"openai": "^4.89.0",
 		"ora": "^8.2.0",
-		"uuid": "^11.1.0"
+		"uuid": "^11.1.0",
+		"boxen": "^8.0.1",
+		"chalk": "^5.4.1",
+		"cli-table3": "^0.6.5",
+		"zod": "^3.23.8"
 	},
 	"engines": {
 		"node": ">=14.0.0"
@@ -78,15 +82,14 @@
 		"url": "https://github.com/eyaltoledano/claude-task-master/issues"
 	},
 	"files": [
-		"scripts/init.js",
-		"scripts/dev.js",
-		"scripts/modules/**",
+		"scripts/**",
 		"assets/**",
 		".cursor/**",
 		"README-task-master.md",
 		"index.js",
 		"bin/**",
-		"mcp-server/**"
+		"mcp-server/**",
+		"src/**"
 	],
 	"overrides": {
 		"node-fetch": "^3.3.2",
@@ -96,9 +99,6 @@
 		"@changesets/changelog-github": "^0.5.1",
 		"@changesets/cli": "^2.28.1",
 		"@types/jest": "^29.5.14",
-		"boxen": "^8.0.1",
-		"chalk": "^5.4.1",
-		"cli-table3": "^0.6.5",
 		"execa": "^8.0.1",
 		"ink": "^5.0.1",
 		"jest": "^29.7.0",
@@ -108,7 +108,6 @@
 		"prettier": "^3.5.3",
 		"react": "^18.3.1",
 		"supertest": "^7.1.0",
-		"tsx": "^4.16.2",
-		"zod": "^3.23.8"
+		"tsx": "^4.16.2"
 	}
 }

scripts/README.md

@@ -32,7 +32,7 @@ The script can be configured through environment variables in a `.env` file at t
 - `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)
+- `TASKMASTER_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
@@ -47,7 +47,7 @@ The script can be configured through environment variables in a `.env` file at t
    - Tasks can have `subtasks` for more detailed implementation steps.
    - Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending) to easily track progress.
 
-2. **Script Commands**  
+2. **Script Commands**
    You can run the script via:
 
    ```bash
@@ -225,7 +225,7 @@ To use the Perplexity integration:
 
 ## Logging
 
-The script supports different logging levels controlled by the `LOG_LEVEL` environment variable:
+The script supports different logging levels controlled by the `TASKMASTER_LOG_LEVEL` environment variable:
 
 - `debug`: Detailed information, typically useful for troubleshooting
 - `info`: Confirmation that things are working as expected (default)

scripts/init.js

@@ -38,10 +38,10 @@ const LOG_LEVELS = {
 	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;
+// Determine log level from environment variable or default to 'info'
+const LOG_LEVEL = process.env.TASKMASTER_LOG_LEVEL
+	? LOG_LEVELS[process.env.TASKMASTER_LOG_LEVEL.toLowerCase()]
+	: LOG_LEVELS.info; // Default to info
 
 // Create a color gradient for the banner
 const coolGradient = gradient(['#00b4d8', '#0077b6', '#03045e']);
@@ -180,9 +180,9 @@ function copyTemplateFile(templateName, targetPath, replacements = {}) {
 
 	// Map template names to their actual source paths
 	switch (templateName) {
-		case 'scripts_README.md':
-			sourcePath = path.join(__dirname, '..', 'assets', 'scripts_README.md');
-			break;
+		// case 'scripts_README.md':
+		// 	sourcePath = path.join(__dirname, '..', 'assets', 'scripts_README.md');
+		// 	break;
 		case 'dev_workflow.mdc':
 			sourcePath = path.join(
 				__dirname,
@@ -219,8 +219,8 @@ function copyTemplateFile(templateName, targetPath, replacements = {}) {
 				'self_improve.mdc'
 			);
 			break;
-		case 'README-task-master.md':
-			sourcePath = path.join(__dirname, '..', 'README-task-master.md');
+			// case 'README-task-master.md':
+			// 	sourcePath = path.join(__dirname, '..', 'README-task-master.md');
 			break;
 		case 'windsurfrules':
 			sourcePath = path.join(__dirname, '..', 'assets', '.windsurfrules');
@@ -351,18 +351,18 @@ async function initializeProject(options = {}) {
 	}
 
 	// Debug logging only if not in silent mode
-	if (!isSilentMode()) {
-		console.log('===== DEBUG: INITIALIZE PROJECT OPTIONS RECEIVED =====');
-		console.log('Full options object:', JSON.stringify(options));
-		console.log('options.yes:', options.yes);
-		console.log('==================================================');
-	}
+	// if (!isSilentMode()) {
+	// 	console.log('===== DEBUG: INITIALIZE PROJECT OPTIONS RECEIVED =====');
+	// 	console.log('Full options object:', JSON.stringify(options));
+	// 	console.log('options.yes:', options.yes);
+	// 	console.log('==================================================');
+	// }
 
 	const skipPrompts = options.yes || (options.name && options.description);
 
-	if (!isSilentMode()) {
-		console.log('Skip prompts determined:', skipPrompts);
-	}
+	// if (!isSilentMode()) {
+	// 	console.log('Skip prompts determined:', skipPrompts);
+	// }
 
 	if (skipPrompts) {
 		if (!isSilentMode()) {
@@ -565,12 +565,12 @@ function createProjectStructure(addAliases, dryRun) {
 		path.join(targetDir, 'scripts', 'example_prd.txt')
 	);
 
-	// Create main README.md
-	copyTemplateFile(
-		'README-task-master.md',
-		path.join(targetDir, 'README-task-master.md'),
-		replacements
-	);
+	// // Create main README.md
+	// copyTemplateFile(
+	// 	'README-task-master.md',
+	// 	path.join(targetDir, 'README-task-master.md'),
+	// 	replacements
+	// );
 
 	// Initialize git repository if git is available
 	try {
@@ -761,21 +761,22 @@ function setupMCPConfiguration(targetDir) {
 	const newMCPServer = {
 		'task-master-ai': {
 			command: 'npx',
-			args: ['-y', 'task-master-mcp'],
+			args: ['-y', '--package=task-master-ai', 'task-master-ai'],
 			env: {
-				ANTHROPIC_API_KEY: 'YOUR_ANTHROPIC_API_KEY',
-				PERPLEXITY_API_KEY: 'YOUR_PERPLEXITY_API_KEY',
-				MODEL: 'claude-3-7-sonnet-20250219',
-				PERPLEXITY_MODEL: 'sonar-pro',
-				MAX_TOKENS: '64000',
-				TEMPERATURE: '0.2',
-				DEFAULT_SUBTASKS: '5',
-				DEFAULT_PRIORITY: 'medium'
+				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'
 			}
 		}
 	};
 
-	// Check if mcp.json already exists
+	// Check if mcp.json already existsimage.png
 	if (fs.existsSync(mcpJsonPath)) {
 		log(
 			'info',
@@ -795,14 +796,14 @@ function setupMCPConfiguration(targetDir) {
 				(server) =>
 					server.args &&
 					server.args.some(
-						(arg) => typeof arg === 'string' && arg.includes('task-master-mcp')
+						(arg) => typeof arg === 'string' && arg.includes('task-master-ai')
 					)
 			);
 
 			if (hasMCPString) {
 				log(
 					'info',
-					'Found existing task-master-mcp configuration in mcp.json, leaving untouched'
+					'Found existing task-master-ai MCP configuration in mcp.json, leaving untouched'
 				);
 				return; // Exit early, don't modify the existing configuration
 			}

scripts/modules/ai-services-unified.js

@@ -14,7 +14,8 @@ import {
 	getResearchModelId,
 	getFallbackProvider,
 	getFallbackModelId,
-	getParametersForRole
+	getParametersForRole,
+	getBaseUrlForRole
 } from './config-manager.js';
 import { log, resolveEnvVariable, findProjectRoot } from './utils.js';
 
@@ -284,7 +285,13 @@ async function _unifiedServiceRunner(serviceType, params) {
 		'AI service call failed for all configured roles.';
 
 	for (const currentRole of sequence) {
-		let providerName, modelId, apiKey, roleParams, providerFnSet, providerApiFn;
+		let providerName,
+			modelId,
+			apiKey,
+			roleParams,
+			providerFnSet,
+			providerApiFn,
+			baseUrl;
 
 		try {
 			log('info', `New AI service call with role: ${currentRole}`);
@@ -325,6 +332,7 @@ async function _unifiedServiceRunner(serviceType, params) {
 
 			// Pass effectiveProjectRoot to getParametersForRole
 			roleParams = getParametersForRole(currentRole, effectiveProjectRoot);
+			baseUrl = getBaseUrlForRole(currentRole, effectiveProjectRoot);
 
 			// 2. Get Provider Function Set
 			providerFnSet = PROVIDER_FUNCTIONS[providerName?.toLowerCase()];
@@ -401,6 +409,7 @@ async function _unifiedServiceRunner(serviceType, params) {
 				maxTokens: roleParams.maxTokens,
 				temperature: roleParams.temperature,
 				messages,
+				baseUrl,
 				...(serviceType === 'generateObject' && { schema, objectName }),
 				...restApiParams
 			};

scripts/modules/commands.js

@@ -10,6 +10,7 @@ import boxen from 'boxen';
 import fs from 'fs';
 import https from 'https';
 import inquirer from 'inquirer';
+import ora from 'ora'; // Import ora
 
 import { log, readJSON } from './utils.js';
 import {
@@ -72,7 +73,11 @@ import {
 	getApiKeyStatusReport
 } from './task-manager/models.js';
 import { findProjectRoot } from './utils.js';
-
+import {
+	isValidTaskStatus,
+	TASK_STATUS_OPTIONS
+} from '../../src/constants/task-status.js';
+import { getTaskMasterVersion } from '../../src/utils/getVersion.js';
 /**
  * Runs the interactive setup process for model configuration.
  * @param {string|null} projectRoot - The resolved project root directory.
@@ -485,11 +490,6 @@ function registerCommands(programInstance) {
 		process.exit(1);
 	});
 
-	// Default help
-	programInstance.on('--help', function () {
-		displayHelp();
-	});
-
 	// parse-prd command
 	programInstance
 		.command('parse-prd')
@@ -514,80 +514,111 @@ function registerCommands(programInstance) {
 			const outputPath = options.output;
 			const force = options.force || false;
 			const append = options.append || false;
+			let useForce = force;
+			let useAppend = false;
 
 			// Helper function to check if tasks.json exists and confirm overwrite
 			async function confirmOverwriteIfNeeded() {
-				if (fs.existsSync(outputPath) && !force && !append) {
-					const shouldContinue = await confirmTaskOverwrite(outputPath);
-					if (!shouldContinue) {
-						console.log(chalk.yellow('Operation cancelled by user.'));
+				if (fs.existsSync(outputPath) && !useForce && !useAppend) {
+					const overwrite = await confirmTaskOverwrite(outputPath);
+					if (!overwrite) {
+						log('info', 'Operation cancelled.');
 						return false;
 					}
+					// If user confirms 'y', we should set useForce = true for the parsePRD call
+					// Only overwrite if not appending
+					useForce = true;
 				}
 				return true;
 			}
 
-			// If no input file specified, check for default PRD location
-			if (!inputFile) {
-				if (fs.existsSync(defaultPrdPath)) {
-					console.log(chalk.blue(`Using default PRD file: ${defaultPrdPath}`));
+			let spinner;
 
-					// Check for existing tasks.json before proceeding
-					if (!(await confirmOverwriteIfNeeded())) return;
+			try {
+				if (!inputFile) {
+					if (fs.existsSync(defaultPrdPath)) {
+						console.log(
+							chalk.blue(`Using default PRD file path: ${defaultPrdPath}`)
+						);
+						if (!(await confirmOverwriteIfNeeded())) return;
 
-					console.log(chalk.blue(`Generating ${numTasks} tasks...`));
-					await parsePRD(defaultPrdPath, outputPath, numTasks, { append });
+						console.log(chalk.blue(`Generating ${numTasks} tasks...`));
+						spinner = ora('Parsing PRD and generating tasks...').start();
+						await parsePRD(defaultPrdPath, outputPath, numTasks, {
+							useAppend,
+							useForce
+						});
+						spinner.succeed('Tasks generated successfully!');
+						return;
+					}
+
+					console.log(
+						chalk.yellow(
+							'No PRD file specified and default PRD file not found at scripts/prd.txt.'
+						)
+					);
+					console.log(
+						boxen(
+							chalk.white.bold('Parse PRD Help') +
+								'\n\n' +
+								chalk.cyan('Usage:') +
+								'\n' +
+								`  task-master parse-prd <prd-file.txt> [options]\n\n` +
+								chalk.cyan('Options:') +
+								'\n' +
+								'  -i, --input <file>       Path to the PRD file (alternative to positional argument)\n' +
+								'  -o, --output <file>      Output file path (default: "tasks/tasks.json")\n' +
+								'  -n, --num-tasks <number> Number of tasks to generate (default: 10)\n' +
+								'  -f, --force              Skip confirmation when overwriting existing tasks\n' +
+								'  --append                 Append new tasks to existing tasks.json instead of overwriting\n\n' +
+								chalk.cyan('Example:') +
+								'\n' +
+								'  task-master parse-prd requirements.txt --num-tasks 15\n' +
+								'  task-master parse-prd --input=requirements.txt\n' +
+								'  task-master parse-prd --force\n' +
+								'  task-master parse-prd requirements_v2.txt --append\n\n' +
+								chalk.yellow('Note: This command will:') +
+								'\n' +
+								'  1. Look for a PRD file at scripts/prd.txt by default\n' +
+								'  2. Use the file specified by --input or positional argument if provided\n' +
+								'  3. Generate tasks from the PRD and either:\n' +
+								'     - Overwrite any existing tasks.json file (default)\n' +
+								'     - Append to existing tasks.json if --append is used',
+							{ padding: 1, borderColor: 'blue', borderStyle: 'round' }
+						)
+					);
 					return;
 				}
 
-				console.log(
-					chalk.yellow(
-						'No PRD file specified and default PRD file not found at scripts/prd.txt.'
-					)
-				);
-				console.log(
-					boxen(
-						chalk.white.bold('Parse PRD Help') +
-							'\n\n' +
-							chalk.cyan('Usage:') +
-							'\n' +
-							`  task-master parse-prd <prd-file.txt> [options]\n\n` +
-							chalk.cyan('Options:') +
-							'\n' +
-							'  -i, --input <file>       Path to the PRD file (alternative to positional argument)\n' +
-							'  -o, --output <file>      Output file path (default: "tasks/tasks.json")\n' +
-							'  -n, --num-tasks <number> Number of tasks to generate (default: 10)\n' +
-							'  -f, --force              Skip confirmation when overwriting existing tasks\n' +
-							'  --append                 Append new tasks to existing tasks.json instead of overwriting\n\n' +
-							chalk.cyan('Example:') +
-							'\n' +
-							'  task-master parse-prd requirements.txt --num-tasks 15\n' +
-							'  task-master parse-prd --input=requirements.txt\n' +
-							'  task-master parse-prd --force\n' +
-							'  task-master parse-prd requirements_v2.txt --append\n\n' +
-							chalk.yellow('Note: This command will:') +
-							'\n' +
-							'  1. Look for a PRD file at scripts/prd.txt by default\n' +
-							'  2. Use the file specified by --input or positional argument if provided\n' +
-							'  3. Generate tasks from the PRD and either:\n' +
-							'     - Overwrite any existing tasks.json file (default)\n' +
-							'     - Append to existing tasks.json if --append is used',
-						{ padding: 1, borderColor: 'blue', borderStyle: 'round' }
-					)
-				);
-				return;
+				if (!fs.existsSync(inputFile)) {
+					console.error(
+						chalk.red(`Error: Input PRD file not found: ${inputFile}`)
+					);
+					process.exit(1);
+				}
+
+				if (!(await confirmOverwriteIfNeeded())) return;
+
+				console.log(chalk.blue(`Parsing PRD file: ${inputFile}`));
+				console.log(chalk.blue(`Generating ${numTasks} tasks...`));
+				if (append) {
+					console.log(chalk.blue('Appending to existing tasks...'));
+				}
+
+				spinner = ora('Parsing PRD and generating tasks...').start();
+				await parsePRD(inputFile, outputPath, numTasks, {
+					append: useAppend,
+					useForce
+				});
+				spinner.succeed('Tasks generated successfully!');
+			} catch (error) {
+				if (spinner) {
+					spinner.fail(`Error parsing PRD: ${error.message}`);
+				} else {
+					console.error(chalk.red(`Error parsing PRD: ${error.message}`));
+				}
+				process.exit(1);
 			}
-
-			// Check for existing tasks.json before proceeding with specified input file
-			if (!(await confirmOverwriteIfNeeded())) return;
-
-			console.log(chalk.blue(`Parsing PRD file: ${inputFile}`));
-			console.log(chalk.blue(`Generating ${numTasks} tasks...`));
-			if (append) {
-				console.log(chalk.blue('Appending to existing tasks...'));
-			}
-
-			await parsePRD(inputFile, outputPath, numTasks, { append });
 		});
 
 	// update command
@@ -1006,7 +1037,7 @@ function registerCommands(programInstance) {
 		)
 		.option(
 			'-s, --status <status>',
-			'New status (todo, in-progress, review, done)'
+			`New status (one of: ${TASK_STATUS_OPTIONS.join(', ')})`
 		)
 		.option('-f, --file <file>', 'Path to the tasks file', 'tasks/tasks.json')
 		.action(async (options) => {
@@ -1019,6 +1050,16 @@ function registerCommands(programInstance) {
 				process.exit(1);
 			}
 
+			if (!isValidTaskStatus(status)) {
+				console.error(
+					chalk.red(
+						`Error: Invalid status value: ${status}. Use one of: ${TASK_STATUS_OPTIONS.join(', ')}`
+					)
+				);
+
+				process.exit(1);
+			}
+
 			console.log(
 				chalk.blue(`Setting status of task(s) ${taskId} to: ${status}`)
 			);
@@ -1031,10 +1072,16 @@ function registerCommands(programInstance) {
 		.command('list')
 		.description('List all tasks')
 		.option('-f, --file <file>', 'Path to the tasks file', 'tasks/tasks.json')
+		.option(
+			'-r, --report <report>',
+			'Path to the complexity report file',
+			'scripts/task-complexity-report.json'
+		)
 		.option('-s, --status <status>', 'Filter by status')
 		.option('--with-subtasks', 'Show subtasks for each task')
 		.action(async (options) => {
 			const tasksPath = options.file;
+			const reportPath = options.report;
 			const statusFilter = options.status;
 			const withSubtasks = options.withSubtasks || false;
 
@@ -1046,7 +1093,7 @@ function registerCommands(programInstance) {
 				console.log(chalk.blue('Including subtasks in listing'));
 			}
 
-			await listTasks(tasksPath, statusFilter, withSubtasks);
+			await listTasks(tasksPath, statusFilter, reportPath, withSubtasks);
 		});
 
 	// expand command
@@ -1246,10 +1293,6 @@ function registerCommands(programInstance) {
 			'--details <details>',
 			'Implementation details (for manual task creation)'
 		)
-		.option(
-			'--test-strategy <testStrategy>',
-			'Test strategy (for manual task creation)'
-		)
 		.option(
 			'--dependencies <dependencies>',
 			'Comma-separated list of task IDs this task depends on'
@@ -1356,9 +1399,15 @@ function registerCommands(programInstance) {
 			`Show the next task to work on based on dependencies and status${chalk.reset('')}`
 		)
 		.option('-f, --file <file>', 'Path to the tasks file', 'tasks/tasks.json')
+		.option(
+			'-r, --report <report>',
+			'Path to the complexity report file',
+			'scripts/task-complexity-report.json'
+		)
 		.action(async (options) => {
 			const tasksPath = options.file;
-			await displayNextTask(tasksPath);
+			const reportPath = options.report;
+			await displayNextTask(tasksPath, reportPath);
 		});
 
 	// show command
@@ -1371,6 +1420,11 @@ function registerCommands(programInstance) {
 		.option('-i, --id <id>', 'Task ID to show')
 		.option('-s, --status <status>', 'Filter subtasks by status') // ADDED status option
 		.option('-f, --file <file>', 'Path to the tasks file', 'tasks/tasks.json')
+		.option(
+			'-r, --report <report>',
+			'Path to the complexity report file',
+			'scripts/task-complexity-report.json'
+		)
 		.action(async (taskId, options) => {
 			const idArg = taskId || options.id;
 			const statusFilter = options.status; // ADDED: Capture status filter
@@ -1381,8 +1435,9 @@ function registerCommands(programInstance) {
 			}
 
 			const tasksPath = options.file;
+			const reportPath = options.report;
 			// PASS statusFilter to the display function
-			await displayTaskById(tasksPath, idArg, statusFilter);
+			await displayTaskById(tasksPath, idArg, reportPath, statusFilter);
 		});
 
 	// add-dependency command
@@ -1631,6 +1686,7 @@ function registerCommands(programInstance) {
 				}
 			} catch (error) {
 				console.error(chalk.red(`Error: ${error.message}`));
+				showAddSubtaskHelp();
 				process.exit(1);
 			}
 		})
@@ -2334,14 +2390,7 @@ function setupCLI() {
 			return 'unknown'; // Default fallback if package.json fails
 		})
 		.helpOption('-h, --help', 'Display help')
-		.addHelpCommand(false) // Disable default help command
-		.on('--help', () => {
-			displayHelp(); // Use your custom help display instead
-		})
-		.on('-h', () => {
-			displayHelp();
-			process.exit(0);
-		});
+		.addHelpCommand(false); // Disable default help command
 
 	// Modify the help option to use your custom display
 	programInstance.helpInformation = () => {
@@ -2361,28 +2410,7 @@ function setupCLI() {
  */
 async function checkForUpdate() {
 	// Get current version from package.json ONLY
-	let currentVersion = 'unknown'; // Initialize with a default
-	try {
-		// Try to get the version from the installed package (if applicable) or current dir
-		let packageJsonPath = path.join(
-			process.cwd(),
-			'node_modules',
-			'task-master-ai',
-			'package.json'
-		);
-		// Fallback to current directory package.json if not found in node_modules
-		if (!fs.existsSync(packageJsonPath)) {
-			packageJsonPath = path.join(process.cwd(), 'package.json');
-		}
-
-		if (fs.existsSync(packageJsonPath)) {
-			const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-			currentVersion = packageJson.version;
-		}
-	} catch (error) {
-		// Silently fail and use default
-		log('debug', `Error reading current package version: ${error.message}`);
-	}
+	const currentVersion = getTaskMasterVersion();
 
 	return new Promise((resolve) => {
 		// Get the latest version from npm registry

scripts/modules/config-manager.js

@@ -677,6 +677,13 @@ function getAllProviders() {
 	return Object.keys(MODEL_MAP || {});
 }
 
+function getBaseUrlForRole(role, explicitRoot = null) {
+	const roleConfig = getModelConfigForRole(role, explicitRoot);
+	return roleConfig && typeof roleConfig.baseUrl === 'string'
+		? roleConfig.baseUrl
+		: undefined;
+}
+
 export {
 	// Core config access
 	getConfig,
@@ -704,6 +711,7 @@ export {
 	getFallbackModelId,
 	getFallbackMaxTokens,
 	getFallbackTemperature,
+	getBaseUrlForRole,
 
 	// Global setting getters (No env var overrides)
 	getLogLevel,

scripts/modules/dependency-manager.js

@@ -195,7 +195,7 @@ async function addDependency(tasksPath, taskId, dependencyId) {
 		}
 
 		// Generate updated task files
-		await generateTaskFiles(tasksPath, 'tasks');
+		await generateTaskFiles(tasksPath, path.dirname(tasksPath));
 
 		log('info', 'Task files regenerated with updated dependencies.');
 	} else {
@@ -334,7 +334,7 @@ async function removeDependency(tasksPath, taskId, dependencyId) {
 	}
 
 	// Regenerate task files
-	await generateTaskFiles(tasksPath, 'tasks');
+	await generateTaskFiles(tasksPath, path.dirname(tasksPath));
 }
 
 /**

scripts/modules/supported-models.json

@@ -13,20 +13,6 @@
 			"cost_per_1m_tokens": { "input": 3.0, "output": 15.0 },
 			"allowed_roles": ["main", "fallback"],
 			"max_tokens": 64000
-		},
-		{
-			"id": "claude-3-5-haiku-20241022",
-			"swe_score": 0.406,
-			"cost_per_1m_tokens": { "input": 0.8, "output": 4.0 },
-			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 64000
-		},
-		{
-			"id": "claude-3-opus-20240229",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 15, "output": 75 },
-			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 64000
 		}
 	],
 	"openai": [
@@ -41,7 +27,7 @@
 			"id": "o1",
 			"swe_score": 0.489,
 			"cost_per_1m_tokens": { "input": 15.0, "output": 60.0 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main"]
 		},
 		{
 			"id": "o3",
@@ -53,7 +39,7 @@
 			"id": "o3-mini",
 			"swe_score": 0.493,
 			"cost_per_1m_tokens": { "input": 1.1, "output": 4.4 },
-			"allowed_roles": ["main", "fallback"],
+			"allowed_roles": ["main"],
 			"max_tokens": 100000
 		},
 		{
@@ -66,49 +52,49 @@
 			"id": "o1-mini",
 			"swe_score": 0.4,
 			"cost_per_1m_tokens": { "input": 1.1, "output": 4.4 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main"]
 		},
 		{
 			"id": "o1-pro",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 150.0, "output": 600.0 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main"]
 		},
 		{
 			"id": "gpt-4-5-preview",
 			"swe_score": 0.38,
 			"cost_per_1m_tokens": { "input": 75.0, "output": 150.0 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main"]
 		},
 		{
 			"id": "gpt-4-1-mini",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0.4, "output": 1.6 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main"]
 		},
 		{
 			"id": "gpt-4-1-nano",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0.1, "output": 0.4 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main"]
 		},
 		{
 			"id": "gpt-4o-mini",
 			"swe_score": 0.3,
 			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main"]
 		},
 		{
 			"id": "gpt-4o-search-preview",
 			"swe_score": 0.33,
 			"cost_per_1m_tokens": { "input": 2.5, "output": 10.0 },
-			"allowed_roles": ["main", "fallback", "research"]
+			"allowed_roles": ["research"]
 		},
 		{
 			"id": "gpt-4o-mini-search-preview",
 			"swe_score": 0.3,
 			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
-			"allowed_roles": ["main", "fallback", "research"]
+			"allowed_roles": ["research"]
 		}
 	],
 	"google": [
@@ -189,14 +175,6 @@
 			"allowed_roles": ["main", "fallback", "research"],
 			"max_tokens": 131072
 		},
-		{
-			"id": "grok-3-mini",
-			"name": "Grok 3 Mini",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0.3, "output": 0.5 },
-			"allowed_roles": ["main", "fallback", "research"],
-			"max_tokens": 131072
-		},
 		{
 			"id": "grok-3-fast",
 			"name": "Grok 3 Fast",
@@ -204,13 +182,6 @@
 			"cost_per_1m_tokens": { "input": 5, "output": 25 },
 			"allowed_roles": ["main", "fallback", "research"],
 			"max_tokens": 131072
-		},
-		{
-			"id": "grok-3-mini-fast",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0.6, "output": 4 },
-			"allowed_roles": ["main", "fallback", "research"],
-			"max_tokens": 131072
 		}
 	],
 	"ollama": [
@@ -283,7 +254,7 @@
 			"id": "deepseek/deepseek-chat-v3-0324",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0.27, "output": 1.1 },
-			"allowed_roles": ["main", "fallback"],
+			"allowed_roles": ["main"],
 			"max_tokens": 64000
 		},
 		{
@@ -312,14 +283,14 @@
 			"id": "google/gemini-2.5-flash-preview",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
-			"allowed_roles": ["main", "fallback"],
+			"allowed_roles": ["main"],
 			"max_tokens": 65535
 		},
 		{
 			"id": "google/gemini-2.5-flash-preview:thinking",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0.15, "output": 3.5 },
-			"allowed_roles": ["main", "fallback"],
+			"allowed_roles": ["main"],
 			"max_tokens": 65535
 		},
 		{

scripts/modules/task-manager.js

@@ -23,7 +23,7 @@ import updateSubtaskById from './task-manager/update-subtask-by-id.js';
 import removeTask from './task-manager/remove-task.js';
 import taskExists from './task-manager/task-exists.js';
 import isTaskDependentOn from './task-manager/is-task-dependent.js';
-
+import { readComplexityReport } from './utils.js';
 // Export task manager functions
 export {
 	parsePRD,
@@ -45,5 +45,6 @@ export {
 	removeTask,
 	findTaskById,
 	taskExists,
-	isTaskDependentOn
+	isTaskDependentOn,
+	readComplexityReport
 };

scripts/modules/task-manager/clear-subtasks.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import boxen from 'boxen';
 import Table from 'cli-table3';
 
-import { log, readJSON, writeJSON, truncate } from '../utils.js';
+import { log, readJSON, writeJSON, truncate, isSilentMode } from '../utils.js';
 import { displayBanner } from '../ui.js';
 import generateTaskFiles from './generate-task-files.js';
 
@@ -22,14 +22,16 @@ function clearSubtasks(tasksPath, taskIds) {
 		process.exit(1);
 	}
 
-	console.log(
-		boxen(chalk.white.bold('Clearing Subtasks'), {
-			padding: 1,
-			borderColor: 'blue',
-			borderStyle: 'round',
-			margin: { top: 1, bottom: 1 }
-		})
-	);
+	if (!isSilentMode()) {
+		console.log(
+			boxen(chalk.white.bold('Clearing Subtasks'), {
+				padding: 1,
+				borderColor: 'blue',
+				borderStyle: 'round',
+				margin: { top: 1, bottom: 1 }
+			})
+		);
+	}
 
 	// Handle multiple task IDs (comma-separated)
 	const taskIdArray = taskIds.split(',').map((id) => id.trim());
@@ -85,59 +87,65 @@ function clearSubtasks(tasksPath, taskIds) {
 		writeJSON(tasksPath, data);
 
 		// Show summary table
-		console.log(
-			boxen(chalk.white.bold('Subtask Clearing Summary:'), {
-				padding: { left: 2, right: 2, top: 0, bottom: 0 },
-				margin: { top: 1, bottom: 0 },
-				borderColor: 'blue',
-				borderStyle: 'round'
-			})
-		);
-		console.log(summaryTable.toString());
+		if (!isSilentMode()) {
+			console.log(
+				boxen(chalk.white.bold('Subtask Clearing Summary:'), {
+					padding: { left: 2, right: 2, top: 0, bottom: 0 },
+					margin: { top: 1, bottom: 0 },
+					borderColor: 'blue',
+					borderStyle: 'round'
+				})
+			);
+			console.log(summaryTable.toString());
+		}
 
 		// Regenerate task files to reflect changes
 		log('info', 'Regenerating task files...');
 		generateTaskFiles(tasksPath, path.dirname(tasksPath));
 
 		// Success message
-		console.log(
-			boxen(
-				chalk.green(
-					`Successfully cleared subtasks from ${chalk.bold(clearedCount)} task(s)`
-				),
-				{
-					padding: 1,
-					borderColor: 'green',
-					borderStyle: 'round',
-					margin: { top: 1 }
-				}
-			)
-		);
+		if (!isSilentMode()) {
+			console.log(
+				boxen(
+					chalk.green(
+						`Successfully cleared subtasks from ${chalk.bold(clearedCount)} task(s)`
+					),
+					{
+						padding: 1,
+						borderColor: 'green',
+						borderStyle: 'round',
+						margin: { top: 1 }
+					}
+				)
+			);
 
-		// Next steps suggestion
-		console.log(
-			boxen(
-				chalk.white.bold('Next Steps:') +
-					'\n\n' +
-					`${chalk.cyan('1.')} Run ${chalk.yellow('task-master expand --id=<id>')} to generate new subtasks\n` +
-					`${chalk.cyan('2.')} Run ${chalk.yellow('task-master list --with-subtasks')} to verify changes`,
-				{
+			// Next steps suggestion
+			console.log(
+				boxen(
+					chalk.white.bold('Next Steps:') +
+						'\n\n' +
+						`${chalk.cyan('1.')} Run ${chalk.yellow('task-master expand --id=<id>')} to generate new subtasks\n` +
+						`${chalk.cyan('2.')} Run ${chalk.yellow('task-master list --with-subtasks')} to verify changes`,
+					{
+						padding: 1,
+						borderColor: 'cyan',
+						borderStyle: 'round',
+						margin: { top: 1 }
+					}
+				)
+			);
+		}
+	} else {
+		if (!isSilentMode()) {
+			console.log(
+				boxen(chalk.yellow('No subtasks were cleared'), {
 					padding: 1,
-					borderColor: 'cyan',
+					borderColor: 'yellow',
 					borderStyle: 'round',
 					margin: { top: 1 }
-				}
-			)
-		);
-	} else {
-		console.log(
-			boxen(chalk.yellow('No subtasks were cleared'), {
-				padding: 1,
-				borderColor: 'yellow',
-				borderStyle: 'round',
-				margin: { top: 1 }
-			})
-		);
+				})
+			);
+		}
 	}
 }
 

scripts/modules/task-manager/find-next-task.js

@@ -1,3 +1,6 @@
+import { log } from '../utils.js';
+import { addComplexityToTask } from '../utils.js';
+
 /**
  * Return the next work item:
  *   •  Prefer an eligible SUBTASK that belongs to any parent task
@@ -15,9 +18,10 @@
  *  ─ parentId      →  number  (present only when it's a subtask)
  *
  * @param {Object[]} tasks  – full array of top-level tasks, each may contain .subtasks[]
+ * @param {Object} [complexityReport=null] - Optional complexity report object
  * @returns {Object|null}   – next work item or null if nothing is eligible
  */
-function findNextTask(tasks) {
+function findNextTask(tasks, complexityReport = null) {
 	// ---------- helpers ----------------------------------------------------
 	const priorityValues = { high: 3, medium: 2, low: 1 };
 
@@ -91,7 +95,14 @@ function findNextTask(tasks) {
 			if (aPar !== bPar) return aPar - bPar;
 			return aSub - bSub;
 		});
-		return candidateSubtasks[0];
+		const nextTask = candidateSubtasks[0];
+
+		// Add complexity to the task before returning
+		if (nextTask && complexityReport) {
+			addComplexityToTask(nextTask, complexityReport);
+		}
+
+		return nextTask;
 	}
 
 	// ---------- 2) fall back to top-level tasks (original logic) ------------
@@ -116,6 +127,11 @@ function findNextTask(tasks) {
 		return a.id - b.id;
 	})[0];
 
+	// Add complexity to the task before returning
+	if (nextTask && complexityReport) {
+		addComplexityToTask(nextTask, complexityReport);
+	}
+
 	return nextTask;
 }
 

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

@@ -2,13 +2,20 @@ import chalk from 'chalk';
 import boxen from 'boxen';
 import Table from 'cli-table3';
 
-import { log, readJSON, truncate } from '../utils.js';
+import {
+	log,
+	readJSON,
+	truncate,
+	readComplexityReport,
+	addComplexityToTask
+} from '../utils.js';
 import findNextTask from './find-next-task.js';
 
 import {
 	displayBanner,
 	getStatusWithColor,
 	formatDependenciesWithStatus,
+	getComplexityWithColor,
 	createProgressBar
 } from '../ui.js';
 
@@ -16,6 +23,7 @@ import {
  * List all tasks
  * @param {string} tasksPath - Path to the tasks.json file
  * @param {string} statusFilter - Filter by status
+ * @param {string} reportPath - Path to the complexity report
  * @param {boolean} withSubtasks - Whether to show subtasks
  * @param {string} outputFormat - Output format (text or json)
  * @returns {Object} - Task list result for json format
@@ -23,6 +31,7 @@ import {
 function listTasks(
 	tasksPath,
 	statusFilter,
+	reportPath = null,
 	withSubtasks = false,
 	outputFormat = 'text'
 ) {
@@ -37,6 +46,13 @@ function listTasks(
 			throw new Error(`No valid tasks found in ${tasksPath}`);
 		}
 
+		// Add complexity scores to tasks if report exists
+		const complexityReport = readComplexityReport(reportPath);
+		// Apply complexity scores to tasks
+		if (complexityReport && complexityReport.complexityAnalysis) {
+			data.tasks.forEach((task) => addComplexityToTask(task, complexityReport));
+		}
+
 		// Filter tasks by status if specified
 		const filteredTasks =
 			statusFilter && statusFilter.toLowerCase() !== 'all' // <-- Added check for 'all'
@@ -257,8 +273,8 @@ function listTasks(
 		);
 		const avgDependenciesPerTask = totalDependencies / data.tasks.length;
 
-		// Find next task to work on
-		const nextItem = findNextTask(data.tasks);
+		// Find next task to work on, passing the complexity report
+		const nextItem = findNextTask(data.tasks, complexityReport);
 
 		// Get terminal width - more reliable method
 		let terminalWidth;
@@ -301,8 +317,11 @@ function listTasks(
 			`${chalk.blue('•')} ${chalk.white('Avg dependencies per task:')} ${avgDependenciesPerTask.toFixed(1)}\n\n` +
 			chalk.cyan.bold('Next Task to Work On:') +
 			'\n' +
-			`ID: ${chalk.cyan(nextItem ? nextItem.id : 'N/A')} - ${nextItem ? chalk.white.bold(truncate(nextItem.title, 40)) : chalk.yellow('No task available')}\n` +
-			`Priority: ${nextItem ? chalk.white(nextItem.priority || 'medium') : ''}  Dependencies: ${nextItem ? formatDependenciesWithStatus(nextItem.dependencies, data.tasks, true) : ''}`;
+			`ID: ${chalk.cyan(nextItem ? nextItem.id : 'N/A')} - ${nextItem ? chalk.white.bold(truncate(nextItem.title, 40)) : chalk.yellow('No task available')}
+` +
+			`Priority: ${nextItem ? chalk.white(nextItem.priority || 'medium') : ''}  Dependencies: ${nextItem ? formatDependenciesWithStatus(nextItem.dependencies, data.tasks, true, complexityReport) : ''}
+` +
+			`Complexity: ${nextItem && nextItem.complexityScore ? getComplexityWithColor(nextItem.complexityScore) : chalk.gray('N/A')}`;
 
 		// Calculate width for side-by-side display
 		// Box borders, padding take approximately 4 chars on each side
@@ -412,9 +431,16 @@ function listTasks(
 		// Make dependencies column smaller as requested (-20%)
 		const depsWidthPct = 20;
 
+		const complexityWidthPct = 10;
+
 		// Calculate title/description width as remaining space (+20% from dependencies reduction)
 		const titleWidthPct =
-			100 - idWidthPct - statusWidthPct - priorityWidthPct - depsWidthPct;
+			100 -
+			idWidthPct -
+			statusWidthPct -
+			priorityWidthPct -
+			depsWidthPct -
+			complexityWidthPct;
 
 		// Allow 10 characters for borders and padding
 		const availableWidth = terminalWidth - 10;
@@ -424,6 +450,9 @@ function listTasks(
 		const statusWidth = Math.floor(availableWidth * (statusWidthPct / 100));
 		const priorityWidth = Math.floor(availableWidth * (priorityWidthPct / 100));
 		const depsWidth = Math.floor(availableWidth * (depsWidthPct / 100));
+		const complexityWidth = Math.floor(
+			availableWidth * (complexityWidthPct / 100)
+		);
 		const titleWidth = Math.floor(availableWidth * (titleWidthPct / 100));
 
 		// Create a table with correct borders and spacing
@@ -433,9 +462,17 @@ function listTasks(
 				chalk.cyan.bold('Title'),
 				chalk.cyan.bold('Status'),
 				chalk.cyan.bold('Priority'),
-				chalk.cyan.bold('Dependencies')
+				chalk.cyan.bold('Dependencies'),
+				chalk.cyan.bold('Complexity')
+			],
+			colWidths: [
+				idWidth,
+				titleWidth,
+				statusWidth,
+				priorityWidth,
+				depsWidth,
+				complexityWidth // Added complexity column width
 			],
-			colWidths: [idWidth, titleWidth, statusWidth, priorityWidth, depsWidth],
 			style: {
 				head: [], // No special styling for header
 				border: [], // No special styling for border
@@ -454,7 +491,8 @@ function listTasks(
 				depText = formatDependenciesWithStatus(
 					task.dependencies,
 					data.tasks,
-					true
+					true,
+					complexityReport
 				);
 			} else {
 				depText = chalk.gray('None');
@@ -480,7 +518,10 @@ function listTasks(
 				truncate(cleanTitle, titleWidth - 3),
 				status,
 				priorityColor(truncate(task.priority || 'medium', priorityWidth - 2)),
-				depText // No truncation for dependencies
+				depText,
+				task.complexityScore
+					? getComplexityWithColor(task.complexityScore)
+					: chalk.gray('N/A')
 			]);
 
 			// Add subtasks if requested
@@ -516,6 +557,8 @@ function listTasks(
 								// Default to regular task dependency
 								const depTask = data.tasks.find((t) => t.id === depId);
 								if (depTask) {
+									// Add complexity to depTask before checking status
+									addComplexityToTask(depTask, complexityReport);
 									const isDone =
 										depTask.status === 'done' || depTask.status === 'completed';
 									const isInProgress = depTask.status === 'in-progress';
@@ -541,7 +584,10 @@ function listTasks(
 						chalk.dim(`└─ ${truncate(subtask.title, titleWidth - 5)}`),
 						getStatusWithColor(subtask.status, true),
 						chalk.dim('-'),
-						subtaskDepText // No truncation for dependencies
+						subtaskDepText,
+						subtask.complexityScore
+							? chalk.gray(`${subtask.complexityScore}`)
+							: chalk.gray('N/A')
 					]);
 				});
 			}
@@ -597,6 +643,8 @@ function listTasks(
 				subtasksSection = `\n\n${chalk.white.bold('Subtasks:')}\n`;
 				subtasksSection += parentTaskForSubtasks.subtasks
 					.map((subtask) => {
+						// Add complexity to subtask before display
+						addComplexityToTask(subtask, complexityReport);
 						// Using a more simplified format for subtask status display
 						const status = subtask.status || 'pending';
 						const statusColors = {
@@ -625,8 +673,8 @@ function listTasks(
 						'\n\n' +
 						// Use nextItem.priority, nextItem.status, nextItem.dependencies
 						`${chalk.white('Priority:')} ${priorityColors[nextItem.priority || 'medium'](nextItem.priority || 'medium')}   ${chalk.white('Status:')} ${getStatusWithColor(nextItem.status, true)}\n` +
-						`${chalk.white('Dependencies:')} ${nextItem.dependencies && nextItem.dependencies.length > 0 ? formatDependenciesWithStatus(nextItem.dependencies, data.tasks, true) : chalk.gray('None')}\n\n` +
-						// Use nextItem.description (Note: findNextTask doesn't return description, need to fetch original task/subtask for this)
+						`${chalk.white('Dependencies:')} ${nextItem.dependencies && nextItem.dependencies.length > 0 ? formatDependenciesWithStatus(nextItem.dependencies, data.tasks, true, complexityReport) : chalk.gray('None')}\n\n` +
+						// Use nextTask.description (Note: findNextTask doesn't return description, need to fetch original task/subtask for this)
 						// *** Fetching original item for description and details ***
 						`${chalk.white('Description:')} ${getWorkItemDescription(nextItem, data.tasks)}` +
 						subtasksSection + // <-- Subtasks are handled above now

scripts/modules/task-manager/set-task-status.js

@@ -8,6 +8,10 @@ import { validateTaskDependencies } from '../dependency-manager.js';
 import { getDebugFlag } from '../config-manager.js';
 import updateSingleTaskStatus from './update-single-task-status.js';
 import generateTaskFiles from './generate-task-files.js';
+import {
+	isValidTaskStatus,
+	TASK_STATUS_OPTIONS
+} from '../../../src/constants/task-status.js';
 
 /**
  * Set the status of a task
@@ -19,6 +23,11 @@ import generateTaskFiles from './generate-task-files.js';
  */
 async function setTaskStatus(tasksPath, taskIdInput, newStatus, options = {}) {
 	try {
+		if (!isValidTaskStatus(newStatus)) {
+			throw new Error(
+				`Error: Invalid status value: ${newStatus}. Use one of: ${TASK_STATUS_OPTIONS.join(', ')}`
+			);
+		}
 		// Determine if we're in MCP mode by checking for mcpLog
 		const isMcpMode = !!options?.mcpLog;
 

scripts/modules/task-manager/update-single-task-status.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 
 import { log } from '../utils.js';
+import { isValidTaskStatus } from '../../../src/constants/task-status.js';
 
 /**
  * Update the status of a single task
@@ -17,6 +18,12 @@ async function updateSingleTaskStatus(
 	data,
 	showUi = true
 ) {
+	if (!isValidTaskStatus(newStatus)) {
+		throw new Error(
+			`Error: Invalid status value: ${newStatus}. Use one of: ${TASK_STATUS_OPTIONS.join(', ')}`
+		);
+	}
+
 	// Check if it's a subtask (e.g., "1.2")
 	if (taskIdInput.includes('.')) {
 		const [parentId, subtaskId] = taskIdInput

scripts/modules/task-manager/update-subtask-by-id.js

@@ -3,6 +3,7 @@ import path from 'path';
 import chalk from 'chalk';
 import boxen from 'boxen';
 import Table from 'cli-table3';
+import { z } from 'zod';
 
 import {
 	getStatusWithColor,
@@ -16,7 +17,10 @@ import {
 	truncate,
 	isSilentMode
 } from '../utils.js';
-import { generateTextService } from '../ai-services-unified.js';
+import {
+	generateObjectService,
+	generateTextService
+} from '../ai-services-unified.js';
 import { getDebugFlag } from '../config-manager.js';
 import generateTaskFiles from './generate-task-files.js';
 
@@ -131,6 +135,17 @@ async function updateSubtaskById(
 
 		const subtask = parentTask.subtasks[subtaskIndex];
 
+		const subtaskSchema = z.object({
+			id: z.number().int().positive(),
+			title: z.string(),
+			description: z.string().optional(),
+			status: z.string(),
+			dependencies: z.array(z.union([z.string(), z.number()])).optional(),
+			priority: z.string().optional(),
+			details: z.string().optional(),
+			testStrategy: z.string().optional()
+		});
+
 		// Only show UI elements for text output (CLI)
 		if (outputFormat === 'text') {
 			// Show the subtask that will be updated
@@ -168,101 +183,155 @@ async function updateSubtaskById(
 			);
 		}
 
-		let additionalInformation = '';
+		let parsedAIResponse;
 		try {
-			// Build Prompts
-			const systemPrompt = `You are an AI assistant helping to update a software development subtask. Your goal is to APPEND new information to the existing details, not replace them. Add a timestamp.
+			// --- GET PARENT & SIBLING CONTEXT ---
+			const parentContext = {
+				id: parentTask.id,
+				title: parentTask.title
+				// Avoid sending full parent description/details unless necessary
+			};
+
+			const prevSubtask =
+				subtaskIndex > 0
+					? {
+							id: `${parentTask.id}.${parentTask.subtasks[subtaskIndex - 1].id}`,
+							title: parentTask.subtasks[subtaskIndex - 1].title,
+							status: parentTask.subtasks[subtaskIndex - 1].status
+						}
+					: null;
+
+			const nextSubtask =
+				subtaskIndex < parentTask.subtasks.length - 1
+					? {
+							id: `${parentTask.id}.${parentTask.subtasks[subtaskIndex + 1].id}`,
+							title: parentTask.subtasks[subtaskIndex + 1].title,
+							status: parentTask.subtasks[subtaskIndex + 1].status
+						}
+					: null;
+
+			const contextString = `
+Parent Task: ${JSON.stringify(parentContext)}
+${prevSubtask ? `Previous Subtask: ${JSON.stringify(prevSubtask)}` : ''}
+${nextSubtask ? `Next Subtask: ${JSON.stringify(nextSubtask)}` : ''}
+`;
+
+			const systemPrompt = `You are an AI assistant updating a parent task's subtask. This subtask will be part of a larger parent task and will be used to direct AI agents to complete the subtask. Your goal is to GENERATE new, relevant information based on the user's request (which may be high-level, mid-level or low-level) and APPEND it to the existing subtask 'details' field, wrapped in specific XML-like tags with an ISO 8601 timestamp. Intelligently determine the level of detail to include based on the user's request. Some requests are meant simply to update the subtask with some mid-implementation details, while others are meant to update the subtask with a detailed plan or strategy.
+
+Context Provided:
+- The current subtask object.
+- Basic info about the parent task (ID, title).
+- Basic info about the immediately preceding subtask (ID, title, status), if it exists.
+- Basic info about the immediately succeeding subtask (ID, title, status), if it exists.
+- A user request string.
 
 Guidelines:
-1. Identify the existing 'details' field in the subtask JSON.
-2. Create a new timestamp string in the format: '[YYYY-MM-DD HH:MM:SS]'.
-3. Append the new timestamp and the information from the user prompt to the *end* of the existing 'details' field.
-4. Ensure the final 'details' field is a single, coherent string with the new information added.
-5. Return the *entire* subtask object as a valid JSON, including the updated 'details' field and all other original fields (id, title, status, dependencies, etc.).`;
+1. Analyze the user request considering the provided subtask details AND the context of the parent and sibling tasks.
+2. GENERATE new, relevant text content that should be added to the 'details' field. Focus *only* on the substance of the update based on the user request and context. Do NOT add timestamps or any special formatting yourself. Avoid over-engineering the details, provide .
+3. Update the 'details' field in the subtask object with the GENERATED text content. It's okay if this overwrites previous details in the object you return, as the calling code will handle the final appending.
+4. Return the *entire* updated subtask object (with your generated content in the 'details' field) as a valid JSON object conforming to the provided schema. Do NOT return explanations or markdown formatting.`;
+
 			const subtaskDataString = JSON.stringify(subtask, null, 2);
-			const userPrompt = `Here is the subtask to update:\n${subtaskDataString}\n\nPlease APPEND the following information to the 'details' field, preceded by a timestamp:\n${prompt}\n\nReturn only the updated subtask as a single, valid JSON object.`;
+			// Updated user prompt including context
+			const userPrompt = `Task Context:\n${contextString}\nCurrent Subtask:\n${subtaskDataString}\n\nUser Request: "${prompt}"\n\nPlease GENERATE new, relevant text content for the 'details' field based on the user request and the provided context. Return the entire updated subtask object as a valid JSON object matching the schema, with the newly generated text placed in the 'details' field.`;
+			// --- END UPDATED PROMPTS ---
 
-			// Call Unified AI Service
+			// Call Unified AI Service using generateObjectService
 			const role = useResearch ? 'research' : 'main';
-			report('info', `Using AI service with role: ${role}`);
+			report('info', `Using AI object service with role: ${role}`);
 
-			const responseText = await generateTextService({
+			parsedAIResponse = await generateObjectService({
 				prompt: userPrompt,
 				systemPrompt: systemPrompt,
+				schema: subtaskSchema,
+				objectName: 'updatedSubtask',
 				role,
 				session,
-				projectRoot
+				projectRoot,
+				maxRetries: 2
 			});
-			report('success', 'Successfully received text response from AI service');
+			report(
+				'success',
+				'Successfully received object response from AI service'
+			);
 
 			if (outputFormat === 'text' && loadingIndicator) {
-				// Stop indicator immediately since generateText is blocking
 				stopLoadingIndicator(loadingIndicator);
 				loadingIndicator = null;
 			}
 
-			// Assign the result directly (generateTextService returns the text string)
-			additionalInformation = responseText ? responseText.trim() : '';
-
-			if (!additionalInformation) {
-				throw new Error('AI returned empty response.'); // Changed error message slightly
+			if (!parsedAIResponse || typeof parsedAIResponse !== 'object') {
+				throw new Error('AI did not return a valid object.');
 			}
+
 			report(
-				// Corrected log message to reflect generateText
 				'success',
-				`Successfully generated text using AI role: ${role}.`
+				`Successfully generated object using AI role: ${role}.`
 			);
 		} catch (aiError) {
 			report('error', `AI service call failed: ${aiError.message}`);
+			if (outputFormat === 'text' && loadingIndicator) {
+				stopLoadingIndicator(loadingIndicator); // Ensure stop on error
+				loadingIndicator = null;
+			}
 			throw aiError;
-		} // Removed the inner finally block as streamingInterval is gone
+		}
 
-		const currentDate = new Date();
+		// --- TIMESTAMP & FORMATTING LOGIC (Handled Locally) ---
+		// Extract only the generated content from the AI's response details field.
+		const generatedContent = parsedAIResponse.details || ''; // Default to empty string
 
-		// Format the additional information with timestamp
-		const formattedInformation = `\n\n<info added on ${currentDate.toISOString()}>\n${additionalInformation}\n</info added on ${currentDate.toISOString()}>`;
+		if (generatedContent.trim()) {
+			// Generate timestamp locally
+			const timestamp = new Date().toISOString(); // <<< Local Timestamp
+
+			// Format the content with XML-like tags and timestamp LOCALLY
+			const formattedBlock = `<info added on ${timestamp}>\n${generatedContent.trim()}\n</info added on ${timestamp}>`; // <<< Local Formatting
+
+			// Append the formatted block to the *original* subtask details
+			subtask.details =
+				(subtask.details ? subtask.details + '\n' : '') + formattedBlock; // <<< Local Appending
+			report(
+				'info',
+				'Appended timestamped, formatted block with AI-generated content to subtask.details.'
+			);
+		} else {
+			report(
+				'warn',
+				'AI response object did not contain generated content in the "details" field. Original details remain unchanged.'
+			);
+		}
+		// --- END TIMESTAMP & FORMATTING LOGIC ---
+
+		// Get a reference to the subtask *after* its details have been updated
+		const updatedSubtask = parentTask.subtasks[subtaskIndex]; // subtask === updatedSubtask now
+
+		report('info', 'Updated subtask details locally after AI generation.');
+		// --- END UPDATE SUBTASK ---
 
 		// Only show debug info for text output (CLI)
 		if (outputFormat === 'text' && getDebugFlag(session)) {
 			console.log(
-				'>>> DEBUG: formattedInformation:',
-				formattedInformation.substring(0, 70) + '...'
+				'>>> DEBUG: Subtask details AFTER AI update:',
+				updatedSubtask.details // Use updatedSubtask
 			);
 		}
 
-		// Append to subtask details and description
-		// Only show debug info for text output (CLI)
-		if (outputFormat === 'text' && getDebugFlag(session)) {
-			console.log('>>> DEBUG: Subtask details BEFORE append:', subtask.details);
-		}
-
-		if (subtask.details) {
-			subtask.details += formattedInformation;
-		} else {
-			subtask.details = `${formattedInformation}`;
-		}
-
-		// Only show debug info for text output (CLI)
-		if (outputFormat === 'text' && getDebugFlag(session)) {
-			console.log('>>> DEBUG: Subtask details AFTER append:', subtask.details);
-		}
-
-		if (subtask.description) {
-			// Only append to description if it makes sense (for shorter updates)
-			if (additionalInformation.length < 200) {
-				// Only show debug info for text output (CLI)
+		// Description update logic (keeping as is for now)
+		if (updatedSubtask.description) {
+			// Use updatedSubtask
+			if (prompt.length < 100) {
 				if (outputFormat === 'text' && getDebugFlag(session)) {
 					console.log(
 						'>>> DEBUG: Subtask description BEFORE append:',
-						subtask.description
+						updatedSubtask.description // Use updatedSubtask
 					);
 				}
-				subtask.description += ` [Updated: ${currentDate.toLocaleDateString()}]`;
-				// Only show debug info for text output (CLI)
+				updatedSubtask.description += ` [Updated: ${new Date().toLocaleDateString()}]`; // Use updatedSubtask
 				if (outputFormat === 'text' && getDebugFlag(session)) {
 					console.log(
 						'>>> DEBUG: Subtask description AFTER append:',
-						subtask.description
+						updatedSubtask.description // Use updatedSubtask
 					);
 				}
 			}
@@ -273,10 +342,7 @@ Guidelines:
 			console.log('>>> DEBUG: About to call writeJSON with updated data...');
 		}
 
-		// Update the subtask in the parent task's array
-		parentTask.subtasks[subtaskIndex] = subtask;
-
-		// Write the updated tasks to the file
+		// Write the updated tasks to the file (parentTask already contains the updated subtask)
 		writeJSON(tasksPath, data);
 
 		// Only show debug info for text output (CLI)
@@ -302,17 +368,18 @@ Guidelines:
 						'\n\n' +
 						chalk.white.bold('Title:') +
 						' ' +
-						subtask.title +
+						updatedSubtask.title +
 						'\n\n' +
-						chalk.white.bold('Information Added:') +
+						// Update the display to show the new details field
+						chalk.white.bold('Updated Details:') +
 						'\n' +
-						chalk.white(truncate(additionalInformation, 300, true)),
+						chalk.white(truncate(updatedSubtask.details || '', 500, true)), // Use updatedSubtask
 					{ padding: 1, borderColor: 'green', borderStyle: 'round' }
 				)
 			);
 		}
 
-		return subtask;
+		return updatedSubtask; // Return the modified subtask object
 	} catch (error) {
 		// Outer catch block handles final errors after loop/attempts
 		// Stop indicator on error - only for text output (CLI)

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

@@ -275,7 +275,7 @@ async function updateTasks(
 					chalk.cyan.bold('Title'),
 					chalk.cyan.bold('Status')
 				],
-				colWidths: [5, 60, 10]
+				colWidths: [5, 70, 20]
 			});
 
 			tasksToUpdate.forEach((task) => {

scripts/modules/ui.js

@@ -9,11 +9,22 @@ import boxen from 'boxen';
 import ora from 'ora';
 import Table from 'cli-table3';
 import gradient from 'gradient-string';
-import { log, findTaskById, readJSON, truncate } from './utils.js';
-import path from 'path';
+import {
+	log,
+	findTaskById,
+	readJSON,
+	truncate,
+	isSilentMode
+} from './utils.js';
 import fs from 'fs';
-import { findNextTask, analyzeTaskComplexity } from './task-manager.js';
+import {
+	findNextTask,
+	analyzeTaskComplexity,
+	readComplexityReport
+} from './task-manager.js';
 import { getProjectName, getDefaultSubtasks } from './config-manager.js';
+import { TASK_STATUS_OPTIONS } from '../../src/constants/task-status.js';
+import { getTaskMasterVersion } from '../../src/utils/getVersion.js';
 
 // Create a color gradient for the banner
 const coolGradient = gradient(['#00b4d8', '#0077b6', '#03045e']);
@@ -23,6 +34,8 @@ const warmGradient = gradient(['#fb8b24', '#e36414', '#9a031e']);
  * Display a fancy banner for the CLI
  */
 function displayBanner() {
+	if (isSilentMode()) return;
+
 	console.clear();
 	const bannerText = figlet.textSync('Task Master', {
 		font: 'Standard',
@@ -38,17 +51,7 @@ function displayBanner() {
 	);
 
 	// Read version directly from package.json
-	let version = 'unknown'; // Initialize with a default
-	try {
-		const packageJsonPath = path.join(process.cwd(), 'package.json');
-		if (fs.existsSync(packageJsonPath)) {
-			const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-			version = packageJson.version;
-		}
-	} catch (error) {
-		// Silently fall back to default version
-		log('warn', 'Could not read package.json for version info.');
-	}
+	const version = getTaskMasterVersion();
 
 	console.log(
 		boxen(
@@ -265,12 +268,14 @@ function getStatusWithColor(status, forTable = false) {
  * @param {Array} dependencies - Array of dependency IDs
  * @param {Array} allTasks - Array of all tasks
  * @param {boolean} forConsole - Whether the output is for console display
+ * @param {Object|null} complexityReport - Optional pre-loaded complexity report
  * @returns {string} Formatted dependencies string
  */
 function formatDependenciesWithStatus(
 	dependencies,
 	allTasks,
-	forConsole = false
+	forConsole = false,
+	complexityReport = null // Add complexityReport parameter
 ) {
 	if (
 		!dependencies ||
@@ -334,7 +339,11 @@ function formatDependenciesWithStatus(
 			typeof depId === 'string' ? parseInt(depId, 10) : depId;
 
 		// Look up the task using the numeric ID
-		const depTaskResult = findTaskById(allTasks, numericDepId);
+		const depTaskResult = findTaskById(
+			allTasks,
+			numericDepId,
+			complexityReport
+		);
 		const depTask = depTaskResult.task; // Access the task object from the result
 
 		if (!depTask) {
@@ -450,7 +459,7 @@ function displayHelp() {
 				{
 					name: 'set-status',
 					args: '--id=<id> --status=<status>',
-					desc: 'Update task status (done, pending, etc.)'
+					desc: `Update task status (${TASK_STATUS_OPTIONS.join(', ')})`
 				},
 				{
 					name: 'update',
@@ -753,7 +762,7 @@ function truncateString(str, maxLength) {
  * Display the next task to work on
  * @param {string} tasksPath - Path to the tasks.json file
  */
-async function displayNextTask(tasksPath) {
+async function displayNextTask(tasksPath, complexityReportPath = null) {
 	displayBanner();
 
 	// Read the tasks file
@@ -763,8 +772,11 @@ async function displayNextTask(tasksPath) {
 		process.exit(1);
 	}
 
+	// Read complexity report once
+	const complexityReport = readComplexityReport(complexityReportPath);
+
 	// Find the next task
-	const nextTask = findNextTask(data.tasks);
+	const nextTask = findNextTask(data.tasks, complexityReport);
 
 	if (!nextTask) {
 		console.log(
@@ -801,12 +813,7 @@ async function displayNextTask(tasksPath) {
 			'padding-bottom': 0,
 			compact: true
 		},
-		chars: {
-			mid: '',
-			'left-mid': '',
-			'mid-mid': '',
-			'right-mid': ''
-		},
+		chars: { mid: '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' },
 		colWidths: [15, Math.min(75, process.stdout.columns - 20 || 60)],
 		wordWrap: true
 	});
@@ -830,7 +837,18 @@ async function displayNextTask(tasksPath) {
 		],
 		[
 			chalk.cyan.bold('Dependencies:'),
-			formatDependenciesWithStatus(nextTask.dependencies, data.tasks, true)
+			formatDependenciesWithStatus(
+				nextTask.dependencies,
+				data.tasks,
+				true,
+				complexityReport
+			)
+		],
+		[
+			chalk.cyan.bold('Complexity:'),
+			nextTask.complexityScore
+				? getComplexityWithColor(nextTask.complexityScore)
+				: chalk.gray('N/A')
 		],
 		[chalk.cyan.bold('Description:'), nextTask.description]
 	);
@@ -894,12 +912,7 @@ async function displayNextTask(tasksPath) {
 				'padding-bottom': 0,
 				compact: true
 			},
-			chars: {
-				mid: '',
-				'left-mid': '',
-				'mid-mid': '',
-				'right-mid': ''
-			},
+			chars: { mid: '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' },
 			wordWrap: true
 		});
 
@@ -1003,7 +1016,12 @@ async function displayNextTask(tasksPath) {
  * @param {string|number} taskId - The ID of the task to display
  * @param {string} [statusFilter] - Optional status to filter subtasks by
  */
-async function displayTaskById(tasksPath, taskId, statusFilter = null) {
+async function displayTaskById(
+	tasksPath,
+	taskId,
+	complexityReportPath = null,
+	statusFilter = null
+) {
 	displayBanner();
 
 	// Read the tasks file
@@ -1013,11 +1031,15 @@ async function displayTaskById(tasksPath, taskId, statusFilter = null) {
 		process.exit(1);
 	}
 
+	// Read complexity report once
+	const complexityReport = readComplexityReport(complexityReportPath);
+
 	// Find the task by ID, applying the status filter if provided
 	// Returns { task, originalSubtaskCount, originalSubtasks }
 	const { task, originalSubtaskCount, originalSubtasks } = findTaskById(
 		data.tasks,
 		taskId,
+		complexityReport,
 		statusFilter
 	);
 
@@ -1072,6 +1094,12 @@ async function displayTaskById(tasksPath, taskId, statusFilter = null) {
 				chalk.cyan.bold('Status:'),
 				getStatusWithColor(task.status || 'pending', true)
 			],
+			[
+				chalk.cyan.bold('Complexity:'),
+				task.complexityScore
+					? getComplexityWithColor(task.complexityScore)
+					: chalk.gray('N/A')
+			],
 			[
 				chalk.cyan.bold('Description:'),
 				task.description || 'No description provided.'
@@ -1150,7 +1178,18 @@ async function displayTaskById(tasksPath, taskId, statusFilter = null) {
 		[chalk.cyan.bold('Priority:'), priorityColor(task.priority || 'medium')],
 		[
 			chalk.cyan.bold('Dependencies:'),
-			formatDependenciesWithStatus(task.dependencies, data.tasks, true)
+			formatDependenciesWithStatus(
+				task.dependencies,
+				data.tasks,
+				true,
+				complexityReport
+			)
+		],
+		[
+			chalk.cyan.bold('Complexity:'),
+			task.complexityScore
+				? getComplexityWithColor(task.complexityScore)
+				: chalk.gray('N/A')
 		],
 		[chalk.cyan.bold('Description:'), task.description]
 	);