fix(typo): second typo in the readme this time.

- Enhance error validation in parse-prd.js and update-tasks.js
- Fix bug where mcpLog was incorrectly passed as logWrapper
- Improve error messages and response formatting
- Add --skip-verification flag to E2E tests
- Update MCP server config that ships with init to match new API key structure
- Fix task force/append handling in parse-prd command
- Increase column width in update-tasks display

.changeset/curvy-candies-eat.md

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

.changeset/fine-monkeys-eat.md

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

.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`).
+      - 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.
-      - Tool `execute` methods call **direct function wrappers** (`mcp-server/src/core/direct-functions/*.js`).
+      - 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/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.
+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:
-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`**.
+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.
-    ```javascript
+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.
-    // Example call (applies to both AI and non-AI direct functions now)
+3.  **Injects Normalized Path:** It updates the `args` object by replacing the original `projectRoot` (or adding it) with the normalized, absolute path.
-    const result = await someDirectFunction(
+4.  **Executes Original Logic:** It calls the original `execute` function body, passing the updated `args` object.
-        { ...args, projectRoot }, // Args including resolved root
+
-        log,                   // MCP logger
+**Implementation Example:**
-        { 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`.
 
 ```javascript
-// Example execute method structure for a tool calling an AI-based direct function
+// In mcp-server/src/tools/your-tool.js
-import { getProjectRootFromSession, handleApiResult, createErrorResponse } from './utils.js';
+import {
-import { someAIDirectFunction } from '../core/task-master-core.js';
+    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({...})
+export function registerYourTool(server) {
-execute: async (args, { log, session }) => { // Note: reportProgress is omitted here
+    server.addTool({
-  try {
+        name: "your_tool",
-    log.info(`Starting AI tool execution with args: ${JSON.stringify(args)}`);
+        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
+            try {
-    let rootFolder = getProjectRootFromSession(session, log);
+                log.info(`Executing your_tool with normalized root: ${projectRoot}`);
-    if (!rootFolder && args.projectRoot) { // Fallback if needed
-      rootFolder = args.projectRoot;
-      log.info(`Using project root from args as fallback: ${rootFolder}`);
-    }
 
-    // 2. Call AI-Based Direct Function (passing only log and session in context)
+                // Resolve paths using the normalized projectRoot
-    const result = await someAIDirectFunction({
+                let tasksPath = findTasksJsonPath({ projectRoot, file: args.file }, log);
-      ...args,
-      projectRoot: rootFolder // Ensure projectRoot is explicitly passed
-    }, log, { session }); // Pass session here, NO reportProgress
 
-    // 3. Handle and Format Response
+                // Call direct function, passing normalized projectRoot if needed by direct func
-    return handleApiResult(result, log);
+                const result = await yourDirectFunction(
+                    {
+                        /* other args */,
+                        projectRoot // Pass it if direct function needs it
+                    },
+                    log,
+                    { session }
+                );
 
-  } catch (error) {
+                return handleApiResult(result, log);
-    log.error(`Error during AI tool execution: ${error.message}`);
+            } catch (error) {
-    return createErrorResponse(error.message);
+                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 parameters**: Make `projectRoot` optional (`z.string().optional().describe(...)`) as the HOF handles fallback.
-    - Define the `parameters` using `zod`. **Crucially, define `projectRoot` as optional**: `projectRoot: z.string().optional().describe(...)`. Include `file` if applicable.
+    - Consider if this operation should run in the background using `AsyncOperationManager`.
-    - Implement the standard `async execute(args, { log, reportProgress, session })` method:
+    - Implement the standard `execute` method **wrapped with `withNormalizedProjectRoot`**:
-      - Get `rootFolder` using `getProjectRootFromSession` (with fallback to `args.projectRoot`).
+      ```javascript
-      - Call `yourCommandDirect({ ...args, projectRoot: rootFolder }, log)`. 
+      execute: withNormalizedProjectRoot(async (args, { log, session }) => {
-      - Pass the result to `handleApiResult(result, log, 'Error Message')`.
+          // 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.
+These utilities specifically support the implementation and execution of MCP tools.
-- **Refer to [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)** for detailed usage patterns within the MCP tool `execute` methods and direct function wrappers.
 
-- **`getProjectRootFromSession(session, log)`**: 
+- **`normalizeProjectRoot(rawPath, log)`**:
-    - ✅ **DO**: Call this utility **within the MCP tool's `execute` method** to extract the project root path from the `session` object.
+    - **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.
-    - Decodes the `file://` URI and handles potential errors.
+    - **Logic**: Decodes URI, strips `file://`, handles Windows drive prefix (`/C:/`), replaces `\` with `/`, uses `path.resolve()`.
-    - Returns the project path string or `null`.
+    - **Usage**: Used internally by `withNormalizedProjectRoot` HOF.
-    - The returned path should then be passed in the `args` object when calling the corresponding `*Direct` function (e.g., `yourDirectFunction({ ...args, projectRoot: rootFolder }, log)`).
+
+- **`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.
+    - **Purpose**: Standardizes the formatting of responses returned by direct functions (`{ success, data/error, fromCache }`) into the MCP response format.
-    - Takes the standard `{ success, data/error, fromCache }` object.
+    - **Usage**: Call this at the end of the tool's `execute` method, passing the result from the direct function call.
-    - Formats the standard MCP success or error response, including the `fromCache` flag.
-    - Uses `processMCPResponseData` by default to filter response data.
-
-- **`executeTaskMasterCommand(command, log, args, projectRootRaw)`**:
-    - Executes a Task Master CLI command as a child process.
-    - Handles fallback between global `task-master` and local `node scripts/dev.js`.
-    - ❌ **DON'T**: Use this as the primary method for MCP tools. Prefer direct function calls via `*Direct` wrappers.
-
-- **`processMCPResponseData(taskOrData, fieldsToRemove)`**:
-    - Filters task data (e.g., removing `details`, `testStrategy`) before sending to the MCP client. Called by `handleApiResult`.
 
 - **`createContentResponse(content)` / `createErrorResponse(errorMessage)`**:
-    - Formatters for standard MCP success/error responses.
+    - **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.
+    - **Purpose**: Utility for implementing caching within direct functions. Checks cache for `cacheKey`; if miss, executes `actionFn`, caches successful result, and returns.
-    - Checks cache, executes `actionFn` on miss, stores result.
+    - **Usage**: Wrap the core logic execution within a direct function call.
-    - Returns standard `{ success, data/error, fromCache: boolean }`.
+
+- **`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
 

.taskmasterconfig

@@ -1,8 +1,8 @@
 {
   "models": {
     "main": {
-      "provider": "anthropic",
+      "provider": "google",
-      "modelId": "claude-3-7-sonnet-20250219",
+      "modelId": "gemini-2.0-flash",
       "maxTokens": 100000,
       "temperature": 0.2
     },
@@ -14,7 +14,7 @@
     },
     "fallback": {
       "provider": "anthropic",
-      "modelId": "claude-3-5-sonnet-20241022",
+      "modelId": "claude-3-7-sonnet-20250219",
       "maxTokens": 120000,
       "temperature": 0.2
     }

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.

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/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
+	// TRUST the projectRoot passed from the tool layer via args
-	// Ensure it's not null, '/', or the home directory
+	// The HOF in the tool layer already normalized and validated it came from a reliable source (args or session)
-	if (
+	const targetDirectory = args.projectRoot;
-		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}'`
-			);
-		}
-	}
 
-	// 3. Validate the final targetDirectory
+	// --- Validate the targetDirectory (basic sanity checks) ---
-	if (!targetDirectory) {
+	if (
-		// This error now covers cases where neither args.projectRoot nor session provided a valid path
+		!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.`,
+				message: `Cannot initialize project: Invalid target directory '${targetDirectory}' received. Please ensure a valid workspace/folder is open or specified.`,
-				details: `Attempted args.projectRoot: ${args.projectRoot}`
+				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/next-task.js

@@ -71,24 +71,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,
+						nextTask: null
-						allTasks: data.tasks
 					}
 				};
 			}
 
+			// Check if it's a subtask
+			const isSubtask =
+				typeof nextTask.id === 'string' && nextTask.id.includes('.');
+
+			const taskOrSubtask = isSubtask ? 'subtask' : 'task';
+
+			const additionalAdvice = isSubtask
+				? 'Subtasks can be updated with timestamped details as you implement them. This is useful for tracking progress, marking milestones and insights (of successful or successive falures in attempting to implement the subtask). Research can be used when updating the subtask to collect up-to-date information, and can be helpful to solve a repeating problem the agent is unable to solve. It is a good idea to get-task the parent task to collect the overall context of the task, and to get-task the subtask to collect the specific details of the subtask.'
+				: 'Tasks can be updated to reflect a change in the direction of the task, or to reformulate the task per your prompt. Research can be used when updating the task to collect up-to-date information. It is best to update subtasks as you work on them, and to update the task for more high-level changes that may affect pending subtasks or the general direction of the task.';
+
 			// Restore normal logging
 			disableSilentMode();
 
 			// Return the next task data with the full tasks array for reference
 			log.info(
-				`Successfully found next task ${nextTask.id}: ${nextTask.title}`
+				`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) {

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)) {
+	if (!projectRoot) {
-		logWrapper.error(
+		logWrapper.error('parsePRDDirect requires a projectRoot argument.');
-			'parsePRDDirect requires an absolute 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,100 @@
  * Direct function implementation for showing task details
  */
 
-import { findTaskById } from '../../../../scripts/modules/utils.js';
+import { findTaskById, readJSON } from '../../../../scripts/modules/utils.js';
-import { readJSON } from '../../../../scripts/modules/utils.js';
 import { getCachedOrExecute } from '../../tools/utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 
 /**
- * Direct function wrapper for showing task details with error handling and caching.
+ * Direct function wrapper for getting task details.
  *
- * @param {Object} args - Command arguments
+ * @param {Object} args - Command arguments.
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
+ * @param {string} args.id - Task ID to show.
- * @param {string} args.id - The ID of the task or subtask to show.
+ * @param {string} [args.file] - Optional path to the tasks file (passed to findTasksJsonPath).
  * @param {string} [args.status] - Optional status to filter subtasks by.
- * @param {Object} log - Logger object
+ * @param {string} args.projectRoot - Absolute path to the project root directory (already normalized by tool).
- * @returns {Promise<Object>} - Task details result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
+ * @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
+	// Destructure session from context if needed later, otherwise ignore
-	const { tasksJsonPath, id, status } = args;
+	// const { session } = context;
+	// Destructure projectRoot and other args. projectRoot is assumed normalized.
+	const { id, file, status, projectRoot } = args;
 
-	if (!tasksJsonPath) {
+	log.info(
-		log.error('showTaskDirect called without tasksJsonPath');
+		`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',
+				code: 'TASKS_FILE_NOT_FOUND',
-				message: 'tasksJsonPath is required'
+				message: `Failed to find tasks.json: ${error.message}`
-			},
+			}
-			fromCache: false
 		};
 	}
+	// --- End Path Resolution ---
 
-	// Validate task ID
+	// --- Rest of the function remains the same, using tasksJsonPath ---
-	const taskId = id;
+	try {
-	if (!taskId) {
+		const tasksData = readJSON(tasksJsonPath);
-		log.error('Task ID is required');
+		if (!tasksData || !tasksData.tasks) {
-		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})` : ''}`
-			);
 			return {
-				success: true,
+				success: false,
-				data: {
+				error: { code: 'INVALID_TASKS_DATA', message: 'Invalid tasks data' }
-					task,
-					originalSubtaskCount,
-					allTasks: data.tasks
-				}
 			};
-		} catch (error) {
+		}
-			// Make sure to restore normal logging even if there's an error
-			disableSilentMode();
 
-			log.error(`Error showing task: ${error.message}`);
+		const { task, originalSubtaskCount } = findTaskById(
+			tasksData.tasks,
+			id,
+			status
+		);
+
+		if (!task) {
 			return {
 				success: false,
 				error: {
-					code: 'CORE_FUNCTION_ERROR',
+					code: 'TASK_NOT_FOUND',
-					message: error.message || 'Failed to show task details'
+					message: `Task or subtask with ID ${id} not found`
 				}
 			};
 		}
-	};
 
-	// Use the caching utility
+		log.info(`Successfully retrieved task ${id}.`);
-	try {
+
-		const result = await getCachedOrExecute({
+		const returnData = { ...task };
-			cacheKey,
+		if (originalSubtaskCount !== null) {
-			actionFn: coreShowTaskAction,
+			returnData._originalSubtaskCount = originalSubtaskCount;
-			log
+			returnData._subtaskFilter = status;
-		});
+		}
-		log.info(`showTaskDirect completed. From cache: ${result.fromCache}`);
+
-		return result; // Returns { success, data/error, fromCache }
+		return { success: true, data: returnData };
 	} catch (error) {
-		// Catch unexpected errors from getCachedOrExecute itself
+		log.error(`Error showing task ${id}: ${error.message}`);
-		disableSilentMode();
-		log.error(
-			`Unexpected error during getCachedOrExecute for showTask: ${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,122 @@
 /**
  * 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 {
-	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 { session } = context;
-	const { tasksJsonPath, from, prompt, research, projectRoot } = args;
+	const { from, prompt, research, file: fileArg, projectRoot } = args;
 
 	// Create the standard logger wrapper
-	const logWrapper = {
+	const logWrapper = createLogWrapper(log);
-		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)
-	};
 
-	// --- Input Validation (Keep existing checks) ---
+	// --- Input Validation ---
-	if (!tasksJsonPath) {
+	if (!projectRoot) {
-		log.error('updateTasksDirect called without tasksJsonPath');
+		logWrapper.error('updateTasksDirect requires a projectRoot argument.');
-		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}`);
 		return {
 			success: false,
 			error: {
-				code: 'INVALID_FROM_ID',
+				code: 'MISSING_ARGUMENT',
-				message: `Invalid from ID: ${from}. Must be a positive integer.`
+				message: 'projectRoot is required.'
-			},
+			}
-			fromCache: false
 		};
 	}
-	const useResearch = research === true;
-	// --- End Input Validation ---
 
-	log.info(
+	if (!from) {
-		`Updating tasks from ID ${fromId}. Research: ${useResearch}. Project Root: ${projectRoot}`
+		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
+		// Call the core updateTasks function
-		const mcpLog = createLogWrapper(log);
+		const result = await updateTasks(
-
+			tasksFile,
-		// Execute core updateTasks function, passing session context AND projectRoot
+			from,
-		await updateTasks(
-			tasksJsonPath,
-			fromId,
 			prompt,
-			useResearch,
+			research,
-			// Pass context with logger wrapper, session, AND projectRoot
+			{
-			{ mcpLog, session, projectRoot },
+				session,
-			'json' // Explicitly request JSON format for MCP
+				mcpLog: logWrapper,
+				projectRoot
+			},
+			'json'
 		);
 
-		// Since updateTasks modifies file and doesn't return data, create success message
+		// updateTasks returns { success: true, updatedTasks: [...] } on success
-		return {
+		if (result && result.success && Array.isArray(result.updatedTasks)) {
-			success: true,
+			logWrapper.success(
-			data: {
+				`Successfully updated ${result.updatedTasks.length} tasks.`
-				message: `Successfully initiated update for tasks from ID ${fromId} based on the prompt.`,
+			);
-				fromId,
+			return {
-				tasksPath: tasksJsonPath,
+				success: true,
-				useResearch
+				data: {
-			},
+					message: `Successfully updated ${result.updatedTasks.length} tasks.`,
-			fromCache: false // Modifies state
+					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/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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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.'
-					);
-				}
-
 				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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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,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(args.projectRoot, args.output)
-					: path.resolve(rootFolder, 'scripts', 'task-complexity-report.json'); // Default location resolved relative to root
+					: 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(
+				return handleApiResult(result, log, 'Error analyzing task complexity');
-					result,
-					log,
-					'Error analyzing task complexity' // Consistent error prefix
-				);
 			} 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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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) {
@@ -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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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
 				const reportPath = args.file
-					? path.resolve(rootFolder, args.file)
+					? path.resolve(args.projectRoot, args.file)
-					: path.resolve(rootFolder, 'scripts', 'task-complexity-report.json');
+					: 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;
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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
 				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(
+				log.error(`Error in expand-task tool: ${error.message}`);
-					`Critical error in ${toolName} tool execute: ${error.message}`
+				return createErrorResponse(error.message);
-				);
-				return createErrorResponse(
-					`Internal tool error (${toolName}): ${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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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.'
-					);
-				}
-
 				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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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) {
@@ -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,7 +7,7 @@ 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';
@@ -21,8 +21,10 @@ function processTaskResponse(data) {
 	if (!data) return data;
 
 	// If we have the expected structure with task and allTasks
-	if (data.task) {
+	if (typeof data === 'object' && data !== null && data.id && data.title) {
-		// Return only the task object, removing the allTasks array
+		// If the data itself looks like the task object, return it
+		return data;
+	} else if (data.task) {
 		return data.task;
 	}
 
@@ -44,44 +46,33 @@ 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'),
 			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 }) => {
+		execute: withNormalizedProjectRoot(async (args, { log }) => {
-			// Log the session right at the start of execute
+			const { id, file, status, projectRoot } = args;
-			log.info(
-				`Session object received in execute: ${JSON.stringify(session)}`
-			); // Use JSON.stringify for better visibility
 
 			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
+				// Resolve the path to tasks.json using the NORMALIZED projectRoot from args
-				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
 				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 +80,13 @@ export function registerShowTaskTool(server) {
 					);
 				}
 
-				log.info(`Attempting to use tasks file path: ${tasksJsonPath}`);
+				// Call the direct function, passing the normalized projectRoot
-
 				const result = await showTaskDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
-						id: args.id,
+						id: id,
-						status: args.status
+						status: status,
+						projectRoot: projectRoot
 					},
 					log
 				);
@@ -108,7 +99,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 +107,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,7 +7,7 @@ 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';
@@ -42,31 +42,19 @@ export function registerListTasksTool(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 tasks with filters: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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) {
 					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}`
 					);
@@ -89,7 +77,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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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
 				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,7 +7,7 @@ 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';
@@ -27,26 +27,15 @@ export function registerNextTaskTool(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(`Finding next task with args: ${JSON.stringify(args)}`);
 
-				// Get project root from args or session
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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) {
@@ -58,9 +47,7 @@ export function registerNextTaskTool(server) {
 
 				const result = await nextTaskDirect(
 					{
-						// Pass the explicitly resolved path
 						tasksJsonPath: tasksJsonPath
-						// No other args specific to this tool
 					},
 					log
 				);
@@ -80,6 +67,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
+				// Call Direct Function - Pass relevant args including projectRoot
-				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
 				const result = await parsePRDDirect(
 					{
-						// Pass args directly needed by the direct function
+						input: args.input,
-						input: args.input, // Pass relative or absolute path
+						output: args.output,
-						output: args.output, // Pass relative or absolute path
+						numTasks: args.numTasks,
-						numTasks: args.numTasks, // Pass number (direct func handles default)
 						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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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) {
@@ -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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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) {
@@ -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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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
 				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,7 +7,7 @@ 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';
@@ -36,26 +36,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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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) {
@@ -65,19 +54,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 +73,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 +80,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(
+					tasksJsonPath = findTasksJsonPath({ projectRoot, file }, log);
-						{ projectRoot: rootFolder, file: args.file },
+					log.info(`${toolName}: Resolved tasks path: ${tasksJsonPath}`);
-						log
-					);
-					log.info(`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,
+						from: from,
-						prompt: args.prompt,
+						prompt: prompt,
-						research: args.research,
+						research: research,
-						projectRoot: rootFolder
+						projectRoot: projectRoot
 					},
 					log,
 					{ session }
 				);
 
-				// 4. Handle Result
+				log.info(
-				log.info(`updateTasksDirect result: success=${result.success}`);
+					`${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}`);
+				log.error(
-				return createErrorResponse(`Internal tool error: ${error.message}`);
+					`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.
+ * Extracts and normalizes the project root path from the MCP session object.
- * @param {Object} session - The FastMCP session object.
+ * @param {Object} session - The MCP session object.
- * @param {Object} log - Logger object.
+ * @param {Object} log - The MCP logger object.
- * @returns {string|null} - The absolute path to the project root, or null if not found.
+ * @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
+		// Fallback 1: Use server path deduction (Cursor IDE)
-		if (session?.roots?.[0]?.uri) {
+		const serverPath = process.argv[1];
-			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/
 		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 = path.dirname(
-				const projectRoot = serverPath.substring(0, mcpServerIndex - 1); // -1 to remove trailing slash
+					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}`);
+					log.info(
-					return projectRoot;
+						`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
+		log.error(`Error in getProjectRootFromSession: ${e.message}`);
-		const serverPath = process.argv[1];
+		// Attempt final fallback to CWD on error
-		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 "/"
 		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
+				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				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.'
-					);
-				}
-
 				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);
 			}
-		}
+		})
 	});
 }

scripts/init.js

@@ -180,9 +180,9 @@ function copyTemplateFile(templateName, targetPath, replacements = {}) {
 
 	// Map template names to their actual source paths
 	switch (templateName) {
-		case 'scripts_README.md':
+		// case 'scripts_README.md':
-			sourcePath = path.join(__dirname, '..', 'assets', 'scripts_README.md');
+		// 	sourcePath = path.join(__dirname, '..', 'assets', 'scripts_README.md');
-			break;
+		// 	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':
+			// case 'README-task-master.md':
-			sourcePath = path.join(__dirname, '..', '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()) {
+	// if (!isSilentMode()) {
-		console.log('===== DEBUG: INITIALIZE PROJECT OPTIONS RECEIVED =====');
+	// 	console.log('===== DEBUG: INITIALIZE PROJECT OPTIONS RECEIVED =====');
-		console.log('Full options object:', JSON.stringify(options));
+	// 	console.log('Full options object:', JSON.stringify(options));
-		console.log('options.yes:', options.yes);
+	// 	console.log('options.yes:', options.yes);
-		console.log('==================================================');
+	// 	console.log('==================================================');
-	}
+	// }
 
 	const skipPrompts = options.yes || (options.name && options.description);
 
-	if (!isSilentMode()) {
+	// if (!isSilentMode()) {
-		console.log('Skip prompts determined:', skipPrompts);
+	// 	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
+	// // Create main README.md
-	copyTemplateFile(
+	// copyTemplateFile(
-		'README-task-master.md',
+	// 	'README-task-master.md',
-		path.join(targetDir, 'README-task-master.md'),
+	// 	path.join(targetDir, 'README-task-master.md'),
-		replacements
+	// 	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',
+				ANTHROPIC_API_KEY: 'ANTHROPIC_API_KEY_HERE',
-				PERPLEXITY_API_KEY: 'YOUR_PERPLEXITY_API_KEY',
+				PERPLEXITY_API_KEY: 'PERPLEXITY_API_KEY_HERE',
-				MODEL: 'claude-3-7-sonnet-20250219',
+				OPENAI_API_KEY: 'OPENAI_API_KEY_HERE',
-				PERPLEXITY_MODEL: 'sonar-pro',
+				GOOGLE_API_KEY: 'GOOGLE_API_KEY_HERE',
-				MAX_TOKENS: '64000',
+				XAI_API_KEY: 'XAI_API_KEY_HERE',
-				TEMPERATURE: '0.2',
+				OPENROUTER_API_KEY: 'OPENROUTER_API_KEY_HERE',
-				DEFAULT_SUBTASKS: '5',
+				MISTRAL_API_KEY: 'MISTRAL_API_KEY_HERE',
-				DEFAULT_PRIORITY: 'medium'
+				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/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 {
@@ -514,80 +515,111 @@ function registerCommands(programInstance) {
 			const outputPath = options.output;
 			const force = options.force || false;
 			const append = options.append || false;
+			let useForce = false;
+			let useAppend = false;
 
 			// Helper function to check if tasks.json exists and confirm overwrite
 			async function confirmOverwriteIfNeeded() {
-				if (fs.existsSync(outputPath) && !force && !append) {
+				if (fs.existsSync(outputPath) && !useForce && !useAppend) {
-					const shouldContinue = await confirmTaskOverwrite(outputPath);
+					const overwrite = await confirmTaskOverwrite(outputPath);
-					if (!shouldContinue) {
+					if (!overwrite) {
-						console.log(chalk.yellow('Operation cancelled by user.'));
+						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
+			let spinner;
-			if (!inputFile) {
-				if (fs.existsSync(defaultPrdPath)) {
-					console.log(chalk.blue(`Using default PRD file: ${defaultPrdPath}`));
 
-					// Check for existing tasks.json before proceeding
+			try {
-					if (!(await confirmOverwriteIfNeeded())) return;
+				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...`));
+						console.log(chalk.blue(`Generating ${numTasks} tasks...`));
-					await parsePRD(defaultPrdPath, outputPath, numTasks, { append });
+						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(
+				if (!fs.existsSync(inputFile)) {
-					chalk.yellow(
+					console.error(
-						'No PRD file specified and default PRD file not found at scripts/prd.txt.'
+						chalk.red(`Error: Input PRD file not found: ${inputFile}`)
-					)
+					);
-				);
+					process.exit(1);
-				console.log(
+				}
-					boxen(
+
-						chalk.white.bold('Parse PRD Help') +
+				if (!(await confirmOverwriteIfNeeded())) return;
-							'\n\n' +
+
-							chalk.cyan('Usage:') +
+				console.log(chalk.blue(`Parsing PRD file: ${inputFile}`));
-							'\n' +
+				console.log(chalk.blue(`Generating ${numTasks} tasks...`));
-							`  task-master parse-prd <prd-file.txt> [options]\n\n` +
+				if (append) {
-							chalk.cyan('Options:') +
+					console.log(chalk.blue('Appending to existing tasks...'));
-							'\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' +
+				spinner = ora('Parsing PRD and generating tasks...').start();
-							'  -n, --num-tasks <number> Number of tasks to generate (default: 10)\n' +
+				await parsePRD(inputFile, outputPath, numTasks, {
-							'  -f, --force              Skip confirmation when overwriting existing tasks\n' +
+					append: useAppend,
-							'  --append                 Append new tasks to existing tasks.json instead of overwriting\n\n' +
+					force: useForce
-							chalk.cyan('Example:') +
+				});
-							'\n' +
+				spinner.succeed('Tasks generated successfully!');
-							'  task-master parse-prd requirements.txt --num-tasks 15\n' +
+			} catch (error) {
-							'  task-master parse-prd --input=requirements.txt\n' +
+				if (spinner) {
-							'  task-master parse-prd --force\n' +
+					spinner.fail(`Error parsing PRD: ${error.message}`);
-							'  task-master parse-prd requirements_v2.txt --append\n\n' +
+				} else {
-							chalk.yellow('Note: This command will:') +
+					console.error(chalk.red(`Error parsing PRD: ${error.message}`));
-							'\n' +
+				}
-							'  1. Look for a PRD file at scripts/prd.txt by default\n' +
+				process.exit(1);
-							'  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;
 			}
-
-			// 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

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/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(
+	if (!isSilentMode()) {
-		boxen(chalk.white.bold('Clearing Subtasks'), {
+		console.log(
-			padding: 1,
+			boxen(chalk.white.bold('Clearing Subtasks'), {
-			borderColor: 'blue',
+				padding: 1,
-			borderStyle: 'round',
+				borderColor: 'blue',
-			margin: { top: 1, bottom: 1 }
+				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(
+		if (!isSilentMode()) {
-			boxen(chalk.white.bold('Subtask Clearing Summary:'), {
+			console.log(
-				padding: { left: 2, right: 2, top: 0, bottom: 0 },
+				boxen(chalk.white.bold('Subtask Clearing Summary:'), {
-				margin: { top: 1, bottom: 0 },
+					padding: { left: 2, right: 2, top: 0, bottom: 0 },
-				borderColor: 'blue',
+					margin: { top: 1, bottom: 0 },
-				borderStyle: 'round'
+					borderColor: 'blue',
-			})
+					borderStyle: 'round'
-		);
+				})
-		console.log(summaryTable.toString());
+			);
+			console.log(summaryTable.toString());
+		}
 
 		// Regenerate task files to reflect changes
 		log('info', 'Regenerating task files...');
 		generateTaskFiles(tasksPath, path.dirname(tasksPath));
 
 		// Success message
-		console.log(
+		if (!isSilentMode()) {
-			boxen(
+			console.log(
-				chalk.green(
+				boxen(
-					`Successfully cleared subtasks from ${chalk.bold(clearedCount)} task(s)`
+					chalk.green(
-				),
+						`Successfully cleared subtasks from ${chalk.bold(clearedCount)} task(s)`
-				{
+					),
-					padding: 1,
+					{
-					borderColor: 'green',
+						padding: 1,
-					borderStyle: 'round',
+						borderColor: 'green',
-					margin: { top: 1 }
+						borderStyle: 'round',
-				}
+						margin: { top: 1 }
-			)
+					}
-		);
+				)
+			);
 
-		// Next steps suggestion
+			// Next steps suggestion
-		console.log(
+			console.log(
-			boxen(
+				boxen(
-				chalk.white.bold('Next Steps:') +
+					chalk.white.bold('Next Steps:') +
-					'\n\n' +
+						'\n\n' +
-					`${chalk.cyan('1.')} Run ${chalk.yellow('task-master expand --id=<id>')} to generate new subtasks\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`,
+						`${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/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
+			// --- GET PARENT & SIBLING CONTEXT ---
-			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.
+			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.
+1. Analyze the user request considering the provided subtask details AND the context of the parent and sibling tasks.
-2. Create a new timestamp string in the format: '[YYYY-MM-DD HH:MM:SS]'.
+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. Append the new timestamp and the information from the user prompt to the *end* of the existing 'details' field.
+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. Ensure the final 'details' field is a single, coherent string with the new information added.
+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.`;
-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.).`;
+
 			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)
+			if (!parsedAIResponse || typeof parsedAIResponse !== 'object') {
-			additionalInformation = responseText ? responseText.trim() : '';
+				throw new Error('AI did not return a valid object.');
-
-			if (!additionalInformation) {
-				throw new Error('AI returned empty response.'); // Changed error message slightly
 			}
+
 			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
+		if (generatedContent.trim()) {
-		const formattedInformation = `\n\n<info added on ${currentDate.toISOString()}>\n${additionalInformation}\n</info added on ${currentDate.toISOString()}>`;
+			// 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:',
+				'>>> DEBUG: Subtask details AFTER AI update:',
-				formattedInformation.substring(0, 70) + '...'
+				updatedSubtask.details // Use updatedSubtask
 			);
 		}
 
-		// Append to subtask details and description
+		// Description update logic (keeping as is for now)
-		// Only show debug info for text output (CLI)
+		if (updatedSubtask.description) {
-		if (outputFormat === 'text' && getDebugFlag(session)) {
+			// Use updatedSubtask
-			console.log('>>> DEBUG: Subtask details BEFORE append:', subtask.details);
+			if (prompt.length < 100) {
-		}
-
-		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)
 				if (outputFormat === 'text' && getDebugFlag(session)) {
 					console.log(
 						'>>> DEBUG: Subtask description BEFORE append:',
-						subtask.description
+						updatedSubtask.description // Use updatedSubtask
 					);
 				}
-				subtask.description += ` [Updated: ${currentDate.toLocaleDateString()}]`;
+				updatedSubtask.description += ` [Updated: ${new Date().toLocaleDateString()}]`; // Use updatedSubtask
-				// Only show debug info for text output (CLI)
 				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
+		// Write the updated tasks to the file (parentTask already contains the updated subtask)
-		parentTask.subtasks[subtaskIndex] = subtask;
-
-		// Write the updated tasks to the file
 		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,7 +9,13 @@ 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 {
+	log,
+	findTaskById,
+	readJSON,
+	truncate,
+	isSilentMode
+} from './utils.js';
 import path from 'path';
 import fs from 'fs';
 import { findNextTask, analyzeTaskComplexity } from './task-manager.js';
@@ -23,6 +29,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',

scripts/sample-prd.txt

@@ -1,3 +0,0 @@
-Task Master PRD
-
-Create a CLI tool for task management

scripts/task-complexity-report.json

@@ -1,7 +1,7 @@
 {
 	"meta": {
-		"generatedAt": "2025-05-01T18:17:08.817Z",
+		"generatedAt": "2025-05-03T04:45:36.864Z",
-		"tasksAnalyzed": 35,
+		"tasksAnalyzed": 36,
 		"thresholdScore": 5,
 		"projectName": "Taskmaster",
 		"usedResearch": false
@@ -10,282 +10,290 @@
 		{
 			"taskId": 24,
 			"taskTitle": "Implement AI-Powered Test Generation Command",
-			"complexityScore": 7,
+			"complexityScore": 8,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of the 'generate-test' command into detailed subtasks covering command structure, AI prompt engineering, test file generation, and integration with existing systems.",
+			"expansionPrompt": "Expand the 'Implement AI-Powered Test Generation Command' task by detailing the specific steps required for AI prompt engineering, including data extraction, prompt formatting, and error handling.",
-			"reasoning": "This task involves creating a new CLI command that leverages AI to generate test files. It requires integration with Claude API, understanding of Jest testing, file system operations, and complex prompt engineering. The task already has 3 subtasks but would benefit from further breakdown to address error handling, documentation, and test validation components."
+			"reasoning": "Requires AI integration, complex logic, and thorough testing. Prompt engineering and API interaction add significant complexity."
 		},
 		{
 			"taskId": 26,
 			"taskTitle": "Implement Context Foundation for AI Operations",
-			"complexityScore": 6,
+			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of the context foundation for AI operations into detailed subtasks covering file context handling, cursor rules integration, context extraction utilities, and command handler updates.",
+			"expansionPrompt": "Expand the 'Implement Context Foundation for AI Operations' task by detailing the specific steps for integrating file reading, cursor rules, and basic context extraction into the Claude API prompts.",
-			"reasoning": "This task involves creating a foundation for context integration in Task Master. It requires implementing file reading functionality, cursor rules integration, and context extraction utilities. The task already has 4 subtasks but would benefit from additional subtasks for testing, documentation, and integration with existing AI operations."
+			"reasoning": "Involves modifying multiple commands and integrating different context sources. Error handling and backwards compatibility are crucial."
 		},
 		{
 			"taskId": 27,
 			"taskTitle": "Implement Context Enhancements for AI Operations",
-			"complexityScore": 7,
+			"complexityScore": 8,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of context enhancements for AI operations into detailed subtasks covering code context extraction, task history context, PRD context integration, and context formatting improvements.",
+			"expansionPrompt": "Expand the 'Implement Context Enhancements for AI Operations' task by detailing the specific steps for code context extraction, task history integration, and PRD context integration, including parsing, summarization, and formatting.",
-			"reasoning": "This task builds upon the foundation from task #26 and adds more sophisticated context features. It involves implementing code context extraction, task history awareness, and PRD integration. The task already has 4 subtasks but would benefit from additional subtasks for testing, documentation, and integration with the foundation context system."
+			"reasoning": "Builds upon the previous task with more sophisticated context extraction and integration. Requires intelligent parsing and summarization."
 		},
 		{
 			"taskId": 28,
 			"taskTitle": "Implement Advanced ContextManager System",
-			"complexityScore": 8,
+			"complexityScore": 9,
 			"recommendedSubtasks": 7,
-			"expansionPrompt": "Break down the implementation of the advanced ContextManager system into detailed subtasks covering class structure, optimization pipeline, command interface, AI service integration, and performance monitoring.",
+			"expansionPrompt": "Expand the 'Implement Advanced ContextManager System' task by detailing the specific steps for creating the ContextManager class, implementing the optimization pipeline, and adding command interface enhancements, including caching and performance monitoring.",
-			"reasoning": "This task involves creating a comprehensive ContextManager class with advanced features like context optimization, prioritization, and intelligent selection. It builds on the previous context tasks and requires sophisticated algorithms for token management and context relevance scoring. The task already has 5 subtasks but would benefit from additional subtasks for testing, documentation, and integration with existing systems."
+			"reasoning": "A comprehensive system requiring careful design, optimization, and testing. Involves complex algorithms and performance considerations."
 		},
 		{
 			"taskId": 32,
 			"taskTitle": "Implement \"learn\" Command for Automatic Cursor Rule Generation",
 			"complexityScore": 9,
-			"recommendedSubtasks": 8,
+			"recommendedSubtasks": 10,
-			"expansionPrompt": "Break down the implementation of the 'learn' command for automatic Cursor rule generation into detailed subtasks covering chat history analysis, rule management, AI integration, and command structure.",
+			"expansionPrompt": "Expand the 'Implement \"learn\" Command for Automatic Cursor Rule Generation' task by detailing the specific steps for Cursor data analysis, rule management, and AI integration, including error handling and performance optimization.",
-			"reasoning": "This task involves creating a complex system that analyzes Cursor's chat history and code changes to automatically generate rule files. It requires sophisticated data analysis, pattern recognition, and AI integration. The task already has 15 subtasks, which is appropriate given its complexity, but could benefit from reorganization into logical groupings."
+			"reasoning": "Requires deep integration with Cursor's data, complex pattern analysis, and AI interaction. Significant error handling and performance optimization are needed."
 		},
 		{
 			"taskId": 40,
 			"taskTitle": "Implement 'plan' Command for Task Implementation Planning",
-			"complexityScore": 5,
+			"complexityScore": 6,
-			"recommendedSubtasks": 5,
+			"recommendedSubtasks": 4,
-			"expansionPrompt": "Break down the implementation of the 'plan' command for task implementation planning into detailed subtasks covering command structure, AI integration, plan formatting, and error handling.",
+			"expansionPrompt": "Expand the 'Implement 'plan' Command for Task Implementation Planning' task by detailing the steps for retrieving task content, generating implementation plans with AI, and formatting the plan within XML tags.",
-			"reasoning": "This task involves creating a new command that generates implementation plans for tasks. It requires integration with AI services, understanding of task structure, and proper formatting of generated plans. The task has no subtasks yet, so creating 5 subtasks would provide a clear implementation path."
+			"reasoning": "Involves AI integration and requires careful formatting and error handling. Switching between Claude and Perplexity adds complexity."
 		},
 		{
 			"taskId": 41,
 			"taskTitle": "Implement Visual Task Dependency Graph in Terminal",
 			"complexityScore": 8,
 			"recommendedSubtasks": 8,
-			"expansionPrompt": "Break down the implementation of the visual task dependency graph in terminal into detailed subtasks covering graph layout algorithms, ASCII/Unicode rendering, color coding, circular dependency detection, and filtering options.",
+			"expansionPrompt": "Expand the 'Implement Visual Task Dependency Graph in Terminal' task by detailing the steps for designing the graph rendering system, implementing layout algorithms, and handling circular dependencies and filtering options.",
-			"reasoning": "This task involves creating a complex visualization system for task dependencies using ASCII/Unicode characters. It requires sophisticated layout algorithms, rendering logic, and user interface considerations. The task already has 10 subtasks, which is appropriate given its complexity."
+			"reasoning": "Requires complex graph algorithms and terminal rendering. Accessibility and performance are important considerations."
 		},
 		{
 			"taskId": 42,
 			"taskTitle": "Implement MCP-to-MCP Communication Protocol",
-			"complexityScore": 9,
+			"complexityScore": 8,
-			"recommendedSubtasks": 10,
+			"recommendedSubtasks": 7,
-			"expansionPrompt": "Break down the implementation of the MCP-to-MCP communication protocol into detailed subtasks covering protocol definition, adapter pattern, client module, reference implementation, and mode switching.",
+			"expansionPrompt": "Expand the 'Implement MCP-to-MCP Communication Protocol' task by detailing the steps for defining the protocol, implementing the adapter pattern, and building the client module, including error handling and security considerations.",
-			"reasoning": "This task involves designing and implementing a standardized communication protocol for Taskmaster to interact with external MCP tools. It requires sophisticated protocol design, authentication mechanisms, error handling, and support for different operational modes. The task already has 8 subtasks but would benefit from additional subtasks for security, testing, and documentation."
+			"reasoning": "Requires designing a new protocol and implementing communication with external systems. Security and error handling are critical."
 		},
 		{
 			"taskId": 43,
 			"taskTitle": "Add Research Flag to Add-Task Command",
-			"complexityScore": 3,
+			"complexityScore": 5,
-			"recommendedSubtasks": 4,
+			"recommendedSubtasks": 3,
-			"expansionPrompt": "Break down the implementation of the research flag for the add-task command into detailed subtasks covering command argument parsing, research subtask generation, integration with existing command, and documentation.",
+			"expansionPrompt": "Expand the 'Add Research Flag to Add-Task Command' task by detailing the steps for updating the command parser, generating research subtasks, and linking them to the parent task.",
-			"reasoning": "This task involves modifying the add-task command to support a new flag that generates research-oriented subtasks. It's relatively straightforward as it builds on existing functionality. The task has no subtasks yet, so creating 4 subtasks would provide a clear implementation path."
+			"reasoning": "Relatively straightforward, but requires careful handling of subtask generation and linking."
 		},
 		{
 			"taskId": 44,
 			"taskTitle": "Implement Task Automation with Webhooks and Event Triggers",
 			"complexityScore": 8,
 			"recommendedSubtasks": 7,
-			"expansionPrompt": "Break down the implementation of task automation with webhooks and event triggers into detailed subtasks covering webhook registration, event system, trigger definition, authentication, and payload templating.",
+			"expansionPrompt": "Expand the 'Implement Task Automation with Webhooks and Event Triggers' task by detailing the steps for implementing the webhook registration system, event system, and trigger definition interface, including security and error handling.",
-			"reasoning": "This task involves creating a sophisticated automation system with webhooks and event triggers. It requires implementing webhook registration, event capturing, trigger definitions, authentication, and integration with existing systems. The task has no subtasks yet, so creating 7 subtasks would provide a clear implementation path for this complex feature."
+			"reasoning": "Requires designing a robust event system and integrating with external services. Security and error handling are critical."
 		},
 		{
 			"taskId": 45,
 			"taskTitle": "Implement GitHub Issue Import Feature",
-			"complexityScore": 5,
+			"complexityScore": 7,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of the GitHub issue import feature into detailed subtasks covering URL parsing, GitHub API integration, task generation, authentication, and error handling.",
+			"expansionPrompt": "Expand the 'Implement GitHub Issue Import Feature' task by detailing the steps for parsing the URL, fetching issue details from the GitHub API, and generating a well-formatted task.",
-			"reasoning": "This task involves adding a feature to import GitHub issues as tasks. It requires integration with the GitHub API, URL parsing, authentication handling, and proper error management. The task has no subtasks yet, so creating 5 subtasks would provide a clear implementation path."
+			"reasoning": "Requires interacting with the GitHub API and handling various error conditions. Authentication adds complexity."
 		},
 		{
 			"taskId": 46,
 			"taskTitle": "Implement ICE Analysis Command for Task Prioritization",
-			"complexityScore": 6,
+			"complexityScore": 7,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of the ICE analysis command for task prioritization into detailed subtasks covering scoring algorithm, report generation, CLI rendering, and integration with existing analysis tools.",
+			"expansionPrompt": "Expand the 'Implement ICE Analysis Command for Task Prioritization' task by detailing the steps for calculating ICE scores, generating the report file, and implementing the CLI rendering.",
-			"reasoning": "This task involves creating a new command that analyzes and ranks tasks based on Impact, Confidence, and Ease scoring. It requires implementing scoring algorithms, report generation, CLI rendering, and integration with existing analysis tools. The task has no subtasks yet, so creating 6 subtasks would provide a clear implementation path."
+			"reasoning": "Requires AI integration for scoring and careful formatting of the report. Integration with existing complexity reports adds complexity."
 		},
 		{
 			"taskId": 47,
 			"taskTitle": "Enhance Task Suggestion Actions Card Workflow",
 			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the enhancement of the task suggestion actions card workflow into detailed subtasks covering task expansion phase, context addition phase, task management phase, and UI/UX improvements.",
+			"expansionPrompt": "Expand the 'Enhance Task Suggestion Actions Card Workflow' task by detailing the steps for implementing the task expansion, context addition, and task management phases, including UI/UX considerations.",
-			"reasoning": "This task involves redesigning the suggestion actions card to implement a structured workflow. It requires implementing multiple phases (expansion, context addition, management) with appropriate UI/UX considerations. The task has no subtasks yet, so creating 6 subtasks would provide a clear implementation path for this moderately complex feature."
+			"reasoning": "Requires significant UI/UX work and careful state management. Integration with existing functionality is crucial."
 		},
 		{
 			"taskId": 48,
 			"taskTitle": "Refactor Prompts into Centralized Structure",
-			"complexityScore": 4,
+			"complexityScore": 5,
-			"recommendedSubtasks": 4,
+			"recommendedSubtasks": 3,
-			"expansionPrompt": "Break down the refactoring of prompts into a centralized structure into detailed subtasks covering directory creation, prompt extraction, function modification, and documentation.",
+			"expansionPrompt": "Expand the 'Refactor Prompts into Centralized Structure' task by detailing the steps for creating the 'prompts' directory, extracting prompts into individual files, and updating functions to import them.",
-			"reasoning": "This task involves restructuring how prompts are managed in the codebase. It's a relatively straightforward refactoring task that requires creating a new directory structure, extracting prompts from functions, and updating references. The task has no subtasks yet, so creating 4 subtasks would provide a clear implementation path."
+			"reasoning": "Primarily a refactoring task, but requires careful attention to detail to avoid breaking existing functionality."
 		},
 		{
 			"taskId": 49,
 			"taskTitle": "Implement Code Quality Analysis Command",
 			"complexityScore": 8,
-			"recommendedSubtasks": 7,
+			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of the code quality analysis command into detailed subtasks covering pattern recognition, best practice verification, improvement recommendations, task integration, and reporting.",
+			"expansionPrompt": "Expand the 'Implement Code Quality Analysis Command' task by detailing the steps for pattern recognition, best practice verification, and improvement recommendations, including AI integration and task creation.",
-			"reasoning": "This task involves creating a sophisticated command that analyzes code quality, identifies patterns, verifies against best practices, and generates improvement recommendations. It requires complex algorithms for code analysis and integration with AI services. The task has no subtasks yet, so creating 7 subtasks would provide a clear implementation path for this complex feature."
+			"reasoning": "Requires complex code analysis and AI integration. Generating actionable recommendations adds complexity."
 		},
 		{
 			"taskId": 50,
 			"taskTitle": "Implement Test Coverage Tracking System by Task",
 			"complexityScore": 9,
-			"recommendedSubtasks": 8,
+			"recommendedSubtasks": 7,
-			"expansionPrompt": "Break down the implementation of the test coverage tracking system by task into detailed subtasks covering data structure design, coverage report parsing, tracking and update generation, CLI commands, and AI-powered test generation.",
+			"expansionPrompt": "Expand the 'Implement Test Coverage Tracking System by Task' task by detailing the steps for creating the tests.json file structure, developing the coverage report parser, and implementing the CLI commands and AI-powered test generation system.",
-			"reasoning": "This task involves creating a comprehensive system for tracking test coverage at the task level. It requires implementing data structures, coverage report parsing, tracking mechanisms, CLI commands, and AI integration. The task already has 5 subtasks but would benefit from additional subtasks for integration testing, documentation, and user experience."
+			"reasoning": "A comprehensive system requiring deep integration with testing tools and AI. Maintaining bidirectional relationships adds complexity."
 		},
 		{
 			"taskId": 51,
 			"taskTitle": "Implement Perplexity Research Command",
-			"complexityScore": 6,
+			"complexityScore": 7,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of the Perplexity research command into detailed subtasks covering API client service, task context extraction, CLI interface, results processing, and caching system.",
+			"expansionPrompt": "Expand the 'Implement Perplexity Research Command' task by detailing the steps for creating the Perplexity API client, implementing task context extraction, and building the CLI interface.",
-			"reasoning": "This task involves creating a command that integrates with Perplexity AI for research purposes. It requires implementing an API client, context extraction, CLI interface, results processing, and caching. The task already has 5 subtasks, which is appropriate for its complexity."
+			"reasoning": "Requires API integration and careful formatting of the research results. Caching adds complexity."
 		},
 		{
 			"taskId": 52,
 			"taskTitle": "Implement Task Suggestion Command for CLI",
-			"complexityScore": 5,
+			"complexityScore": 7,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of the task suggestion command for CLI into detailed subtasks covering task data collection, AI integration, suggestion presentation, interactive interface, and configuration options.",
+			"expansionPrompt": "Expand the 'Implement Task Suggestion Command for CLI' task by detailing the steps for collecting existing task data, generating task suggestions with AI, and implementing the interactive CLI interface.",
-			"reasoning": "This task involves creating a new CLI command that generates contextually relevant task suggestions. It requires collecting existing task data, integrating with AI services, presenting suggestions, and implementing an interactive interface. The task has no subtasks yet, so creating 5 subtasks would provide a clear implementation path."
+			"reasoning": "Requires AI integration and careful design of the interactive interface. Handling various flag combinations adds complexity."
 		},
 		{
 			"taskId": 53,
 			"taskTitle": "Implement Subtask Suggestion Feature for Parent Tasks",
-			"complexityScore": 6,
+			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of the subtask suggestion feature for parent tasks into detailed subtasks covering parent task validation, context gathering, AI integration, interactive interface, and subtask linking.",
+			"expansionPrompt": "Expand the 'Implement Subtask Suggestion Feature for Parent Tasks' task by detailing the steps for validating parent tasks, gathering context, generating subtask suggestions with AI, and implementing the interactive CLI interface.",
-			"reasoning": "This task involves creating a feature that suggests contextually relevant subtasks for existing parent tasks. It requires implementing parent task validation, context gathering, AI integration, an interactive interface, and subtask linking. The task already has 6 subtasks, which is appropriate for its complexity."
+			"reasoning": "Requires AI integration and careful design of the interactive interface. Linking subtasks to parent tasks adds complexity."
 		},
 		{
 			"taskId": 55,
 			"taskTitle": "Implement Positional Arguments Support for CLI Commands",
-			"complexityScore": 5,
+			"complexityScore": 7,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of positional arguments support for CLI commands into detailed subtasks covering argument parsing logic, command mapping, help text updates, error handling, and testing.",
+			"expansionPrompt": "Expand the 'Implement Positional Arguments Support for CLI Commands' task by detailing the steps for updating the argument parsing logic, defining the positional argument order, and handling edge cases.",
-			"reasoning": "This task involves modifying the command parsing logic to support positional arguments alongside the existing flag-based syntax. It requires updating argument parsing, mapping positional arguments to parameters, updating help text, and handling edge cases. The task has no subtasks yet, so creating 5 subtasks would provide a clear implementation path."
+			"reasoning": "Requires careful modification of the command parsing logic and ensuring backward compatibility. Handling edge cases adds complexity."
 		},
 		{
 			"taskId": 57,
 			"taskTitle": "Enhance Task-Master CLI User Experience and Interface",
 			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the enhancement of the Task-Master CLI user experience and interface into detailed subtasks covering log management, visual enhancements, interactive elements, output formatting, and help documentation.",
+			"expansionPrompt": "Expand the 'Enhance Task-Master CLI User Experience and Interface' task by detailing the steps for log management, visual enhancements, interactive elements, and output formatting.",
-			"reasoning": "This task involves improving the CLI's user experience through various enhancements to logging, visuals, interactivity, and documentation. It requires implementing log levels, visual improvements, interactive elements, and better formatting. The task has no subtasks yet, so creating 6 subtasks would provide a clear implementation path for this moderately complex feature."
+			"reasoning": "Requires significant UI/UX work and careful consideration of different terminal environments. Reducing verbose logging adds complexity."
 		},
 		{
 			"taskId": 60,
 			"taskTitle": "Implement Mentor System with Round-Table Discussion Feature",
 			"complexityScore": 8,
 			"recommendedSubtasks": 7,
-			"expansionPrompt": "Break down the implementation of the mentor system with round-table discussion feature into detailed subtasks covering mentor management, round-table discussion, task system integration, LLM integration, and documentation.",
+			"expansionPrompt": "Expand the 'Implement Mentor System with Round-Table Discussion Feature' task by detailing the steps for mentor management, round-table discussion implementation, and integration with the task system, including LLM integration.",
-			"reasoning": "This task involves creating a sophisticated mentor system with round-table discussions. It requires implementing mentor management, discussion simulation, task integration, and LLM integration. The task has no subtasks yet, so creating 7 subtasks would provide a clear implementation path for this complex feature."
+			"reasoning": "Requires complex AI simulation and careful formatting of the discussion output. Integrating with the task system adds complexity."
 		},
 		{
 			"taskId": 61,
 			"taskTitle": "Implement Flexible AI Model Management",
-			"complexityScore": 10,
+			"complexityScore": 9,
-			"recommendedSubtasks": 10,
+			"recommendedSubtasks": 8,
-			"expansionPrompt": "Break down the implementation of flexible AI model management into detailed subtasks covering configuration management, CLI command parsing, AI SDK integration, service module development, environment variable handling, and documentation.",
+			"expansionPrompt": "Expand the 'Implement Flexible AI Model Management' task by detailing the steps for creating the configuration management module, implementing the CLI command parser, and integrating the Vercel AI SDK.",
-			"reasoning": "This task involves implementing comprehensive support for multiple AI models with a unified interface. It's extremely complex, requiring configuration management, CLI commands, SDK integration, service modules, and environment handling. The task already has 45 subtasks, which is appropriate given its complexity and scope."
+			"reasoning": "Requires deep integration with multiple AI models and careful management of API keys and configuration options. Vercel AI SDK integration adds complexity."
 		},
 		{
 			"taskId": 62,
 			"taskTitle": "Add --simple Flag to Update Commands for Direct Text Input",
-			"complexityScore": 4,
+			"complexityScore": 5,
-			"recommendedSubtasks": 5,
+			"recommendedSubtasks": 4,
-			"expansionPrompt": "Break down the implementation of the --simple flag for update commands into detailed subtasks covering command parser updates, AI processing bypass, timestamp formatting, visual indicators, and documentation.",
+			"expansionPrompt": "Expand the 'Add --simple Flag to Update Commands for Direct Text Input' task by detailing the steps for updating the command parsers, implementing the conditional logic, and formatting the user input with a timestamp.",
-			"reasoning": "This task involves modifying update commands to accept a flag that bypasses AI processing. It requires updating command parsers, implementing conditional logic, formatting user input, and updating documentation. The task already has 8 subtasks, which is more than sufficient for its complexity."
+			"reasoning": "Relatively straightforward, but requires careful attention to formatting and ensuring consistency with AI-processed updates."
 		},
 		{
 			"taskId": 63,
 			"taskTitle": "Add pnpm Support for the Taskmaster Package",
-			"complexityScore": 5,
+			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of pnpm support for the Taskmaster package into detailed subtasks covering documentation updates, package script compatibility, lockfile generation, installation testing, CI/CD integration, and website consistency verification.",
+			"expansionPrompt": "Expand the 'Add pnpm Support for the Taskmaster Package' task by detailing the steps for updating the documentation, ensuring package scripts compatibility, and testing the installation and operation with pnpm.",
-			"reasoning": "This task involves ensuring the Taskmaster package works seamlessly with pnpm. It requires updating documentation, ensuring script compatibility, testing installation, and integrating with CI/CD. The task already has 8 subtasks, which is appropriate for its complexity."
+			"reasoning": "Requires careful attention to detail to ensure compatibility with pnpm's execution model. Testing and documentation are crucial."
 		},
 		{
 			"taskId": 64,
 			"taskTitle": "Add Yarn Support for Taskmaster Installation",
-			"complexityScore": 5,
+			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of Yarn support for Taskmaster installation into detailed subtasks covering package.json updates, Yarn-specific configuration, compatibility testing, documentation updates, package manager detection, and website consistency verification.",
+			"expansionPrompt": "Expand the 'Add Yarn Support for Taskmaster Installation' task by detailing the steps for updating package.json, adding Yarn-specific configuration files, and testing the installation and operation with Yarn.",
-			"reasoning": "This task involves ensuring the Taskmaster package works seamlessly with Yarn. It requires updating package.json, adding Yarn-specific configuration, testing compatibility, and updating documentation. The task already has 9 subtasks, which is appropriate for its complexity."
+			"reasoning": "Requires careful attention to detail to ensure compatibility with Yarn's execution model. Testing and documentation are crucial."
 		},
 		{
 			"taskId": 65,
 			"taskTitle": "Add Bun Support for Taskmaster Installation",
-			"complexityScore": 5,
+			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of Bun support for Taskmaster installation into detailed subtasks covering package.json updates, Bun-specific configuration, compatibility testing, documentation updates, package manager detection, and troubleshooting guidance.",
+			"expansionPrompt": "Expand the 'Add Bun Support for Taskmaster Installation' task by detailing the steps for updating the installation scripts, testing the installation and operation with Bun, and updating the documentation.",
-			"reasoning": "This task involves ensuring the Taskmaster package works seamlessly with Bun. It requires updating package.json, adding Bun-specific configuration, testing compatibility, and updating documentation. The task has no subtasks yet, so creating 6 subtasks would provide a clear implementation path."
+			"reasoning": "Requires careful attention to detail to ensure compatibility with Bun's execution model. Testing and documentation are crucial."
 		},
 		{
 			"taskId": 66,
 			"taskTitle": "Support Status Filtering in Show Command for Subtasks",
-			"complexityScore": 3,
+			"complexityScore": 5,
 			"recommendedSubtasks": 4,
-			"expansionPrompt": "Break down the implementation of status filtering in the show command for subtasks into detailed subtasks covering command parser updates, filtering logic, help documentation, and testing.",
+			"expansionPrompt": "Expand the 'Support Status Filtering in Show Command for Subtasks' task by detailing the steps for updating the command parser, modifying the show command handler, and updating the help documentation.",
-			"reasoning": "This task involves enhancing the show command to support status-based filtering of subtasks. It's relatively straightforward, requiring updates to the command parser, filtering logic, and documentation. The task has no subtasks yet, so creating 4 subtasks would provide a clear implementation path."
+			"reasoning": "Relatively straightforward, but requires careful handling of status validation and filtering."
 		},
 		{
 			"taskId": 67,
 			"taskTitle": "Add CLI JSON output and Cursor keybindings integration",
-			"complexityScore": 6,
+			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of CLI JSON output and Cursor keybindings integration into detailed subtasks covering JSON flag implementation, output formatting, keybindings command structure, OS detection, file handling, and keybinding definition.",
+			"expansionPrompt": "Expand the 'Add CLI JSON output and Cursor keybindings integration' task by detailing the steps for implementing the JSON output logic, creating the install-keybindings command structure, and handling keybinding file manipulation.",
-			"reasoning": "This task involves two main components: adding JSON output to CLI commands and creating a new command for Cursor keybindings. It requires implementing a JSON flag, formatting output, creating a new command, detecting OS, handling files, and defining keybindings. The task already has 5 subtasks, which is appropriate for its complexity."
+			"reasoning": "Requires careful formatting of the JSON output and handling of file system operations. OS detection adds complexity."
 		},
 		{
 			"taskId": 68,
 			"taskTitle": "Ability to create tasks without parsing PRD",
-			"complexityScore": 4,
+			"complexityScore": 3,
-			"recommendedSubtasks": 4,
+			"recommendedSubtasks": 2,
-			"expansionPrompt": "Break down the implementation of creating tasks without parsing PRD into detailed subtasks covering tasks.json creation, function reuse from parse-prd, command modification, and documentation.",
+			"expansionPrompt": "Expand the 'Ability to create tasks without parsing PRD' task by detailing the steps for creating tasks without a PRD.",
-			"reasoning": "This task involves modifying the task creation process to work without a PRD. It's relatively straightforward, requiring tasks.json creation, function reuse, command modification, and documentation. The task has no subtasks yet, so creating 4 subtasks would provide a clear implementation path."
+			"reasoning": "Simple task to allow task creation without a PRD."
 		},
 		{
 			"taskId": 69,
 			"taskTitle": "Enhance Analyze Complexity for Specific Task IDs",
-			"complexityScore": 5,
+			"complexityScore": 6,
-			"recommendedSubtasks": 5,
+			"recommendedSubtasks": 4,
-			"expansionPrompt": "Break down the enhancement of analyze-complexity for specific task IDs into detailed subtasks covering core logic modification, CLI command updates, MCP tool updates, report handling, and testing.",
+			"expansionPrompt": "Expand the 'Enhance Analyze Complexity for Specific Task IDs' task by detailing the steps for modifying the core logic, updating the CLI, and updating the MCP tool.",
-			"reasoning": "This task involves modifying the analyze-complexity feature to support analyzing specific task IDs. It requires updating core logic, CLI commands, MCP tools, and report handling. The task has no subtasks yet, so creating 5 subtasks would provide a clear implementation path."
+			"reasoning": "Requires modifying existing functionality and ensuring compatibility with both CLI and MCP."
 		},
 		{
 			"taskId": 70,
 			"taskTitle": "Implement 'diagram' command for Mermaid diagram generation",
 			"complexityScore": 6,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 4,
-			"expansionPrompt": "Break down the implementation of the 'diagram' command for Mermaid diagram generation into detailed subtasks covering command structure, task data collection, diagram generation, rendering options, file export, and documentation.",
+			"expansionPrompt": "Expand the 'Implement 'diagram' command for Mermaid diagram generation' task by detailing the steps for creating the command, generating the Mermaid diagram, and handling different output options.",
-			"reasoning": "This task involves creating a new command that generates Mermaid diagrams for task dependencies. It requires implementing command structure, collecting task data, generating diagrams, providing rendering options, and supporting file export. The task has no subtasks yet, so creating 6 subtasks would provide a clear implementation path."
+			"reasoning": "Requires generating Mermaid diagrams and handling different output options."
 		},
 		{
 			"taskId": 72,
 			"taskTitle": "Implement PDF Generation for Project Progress and Dependency Overview",
-			"complexityScore": 7,
+			"complexityScore": 8,
-			"recommendedSubtasks": 7,
+			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of PDF generation for project progress and dependency overview into detailed subtasks covering command structure, data collection, progress summary generation, dependency visualization, PDF creation, styling, and documentation.",
+			"expansionPrompt": "Expand the 'Implement PDF Generation for Project Progress and Dependency Overview' task by detailing the steps for summarizing project progress, visualizing the dependency chain, and generating the PDF document.",
-			"reasoning": "This task involves creating a feature to generate PDF reports of project progress and dependencies. It requires implementing command structure, collecting data, generating summaries, visualizing dependencies, creating PDFs, and styling the output. The task has no subtasks yet, so creating 7 subtasks would provide a clear implementation path for this moderately complex feature."
+			"reasoning": "Requires integrating with the diagram command and using a PDF generation library. Handling large dependency chains adds complexity."
 		},
 		{
 			"taskId": 73,
 			"taskTitle": "Implement Custom Model ID Support for Ollama/OpenRouter",
-			"complexityScore": 5,
+			"complexityScore": 7,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of custom model ID support for Ollama/OpenRouter into detailed subtasks covering CLI flag implementation, model validation, interactive setup, configuration updates, and documentation.",
+			"expansionPrompt": "Expand the 'Implement Custom Model ID Support for Ollama/OpenRouter' task by detailing the steps for modifying the CLI, implementing the interactive setup, and handling validation and warnings.",
-			"reasoning": "This task involves allowing users to specify custom model IDs for Ollama and OpenRouter. It requires implementing CLI flags, validating models, updating the interactive setup, modifying configuration, and updating documentation. The task has no subtasks yet, so creating 5 subtasks would provide a clear implementation path."
+			"reasoning": "Requires integrating with external APIs and handling different model types. Validation and warnings are crucial."
 		},
 		{
 			"taskId": 75,
 			"taskTitle": "Integrate Google Search Grounding for Research Role",
-			"complexityScore": 4,
+			"complexityScore": 6,
 			"recommendedSubtasks": 4,
-			"expansionPrompt": "Break down the integration of Google Search Grounding for research role into detailed subtasks covering AI service layer modification, conditional logic implementation, model configuration updates, and testing.",
+			"expansionPrompt": "Expand the 'Integrate Google Search Grounding for Research Role' task by detailing the steps for modifying the AI service layer, implementing the conditional logic, and updating the supported models.",
-			"reasoning": "This task involves updating the AI service layer to enable Google Search Grounding for the research role. It's relatively straightforward, requiring modifications to the AI service, implementing conditional logic, updating model configurations, and testing. The task has no subtasks yet, so creating 4 subtasks would provide a clear implementation path."
+			"reasoning": "Requires conditional logic and integration with the Google Search Grounding API."
+		},
+		{
+			"taskId": 76,
+			"taskTitle": "Develop E2E Test Framework for Taskmaster MCP Server (FastMCP over stdio)",
+			"complexityScore": 9,
+			"recommendedSubtasks": 7,
+			"expansionPrompt": "Expand the 'Develop E2E Test Framework for Taskmaster MCP Server (FastMCP over stdio)' task by detailing the steps for launching the FastMCP server, implementing the message protocol handler, and developing the request/response correlation mechanism.",
+			"reasoning": "Requires complex system integration and robust error handling. Designing a comprehensive test framework adds complexity."
 		}
 	]
 }

tasks/task_040.txt

@@ -37,3 +37,29 @@ Test cases should include:
 - Running the command on tasks with existing implementation plans to ensure proper appending
 
 Manually review the quality of generated plans to ensure they provide actionable, step-by-step guidance that accurately reflects the task requirements.
+
+# Subtasks:
+## 1. Retrieve Task Content [in-progress]
+### Dependencies: None
+### Description: Fetch the content of the specified task from the task management system. This includes the task title, description, and any associated details.
+### Details:
+Implement a function to retrieve task details based on a task ID. Handle cases where the task does not exist.
+
+## 2. Generate Implementation Plan with AI [pending]
+### Dependencies: 40.1
+### Description: Use an AI model (Claude or Perplexity) to generate an implementation plan based on the retrieved task content. The plan should outline the steps required to complete the task.
+### Details:
+Implement logic to switch between Claude and Perplexity APIs. Handle API authentication and rate limiting. Prompt the AI model with the task content and request a detailed implementation plan.
+
+## 3. Format Plan in XML [pending]
+### Dependencies: 40.2, 40.2
+### Description: Format the generated implementation plan within XML tags. Each step in the plan should be represented as an XML element with appropriate attributes.
+### Details:
+Define the XML schema for the implementation plan. Implement a function to convert the AI-generated plan into the defined XML format. Ensure proper XML syntax and validation.
+
+## 4. Error Handling and Output [pending]
+### Dependencies: 40.3
+### Description: Implement error handling for all steps, including API failures and XML formatting errors. Output the formatted XML plan to the console or a file.
+### Details:
+Add try-except blocks to handle potential exceptions. Log errors for debugging. Provide informative error messages to the user. Output the XML plan in a user-friendly format.
+

tasks/task_061.txt

@@ -1962,9 +1962,9 @@ Implementation notes:
 - This stricter approach enforces configuration-as-code principles, ensures reproducibility, and prevents configuration drift, aligning with modern best practices for immutable infrastructure and automated configuration management[2][4].
 </info added on 2025-04-22T02:41:51.174Z>
 
-## 31. Implement Integration Tests for Unified AI Service [pending]
+## 31. Implement Integration Tests for Unified AI Service [done]
 ### Dependencies: 61.18
-### Description: Implement integration tests for `ai-services-unified.js`. These tests should verify the correct routing to different provider modules based on configuration and ensure the unified service functions (`generateTextService`, `generateObjectService`, etc.) work correctly when called from modules like `task-manager.js`.
+### Description: Implement integration tests for `ai-services-unified.js`. These tests should verify the correct routing to different provider modules based on configuration and ensure the unified service functions (`generateTextService`, `generateObjectService`, etc.) work correctly when called from modules like `task-manager.js`. [Updated: 5/2/2025] [Updated: 5/2/2025] [Updated: 5/2/2025] [Updated: 5/2/2025]
 ### Details:
 
 
@@ -2009,6 +2009,107 @@ For the integration tests of the Unified AI Service, consider the following impl
 6. Include tests for configuration changes at runtime and their effect on service behavior.
 </info added on 2025-04-20T03:51:23.368Z>
 
+<info added on 2025-05-02T18:41:13.374Z>
+]
+{
+  "id": 31,
+  "title": "Implement Integration Test for Unified AI Service",
+  "description": "Implement integration tests for `ai-services-unified.js`. These tests should verify the correct routing to different provider module based on configuration and ensure the unified service function (`generateTextService`, `generateObjectService`, etc.) work correctly when called from module like `task-manager.js`.",
+  "details": "\n\n<info added on 2025-04-20T03:51:23.368Z>\nFor the integration test of the Unified AI Service, consider the following implementation details:\n\n1. Setup test fixture:\n   - Create a mock `.taskmasterconfig` file with different provider configuration\n   - Define test case with various model selection and parameter setting\n   - Use environment variable mock only for API key (e.g., `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`)\n\n2. Test configuration resolution:\n   - Verify that `ai-services-unified.js` correctly retrieve setting from `config-manager.js`\n   - Test that model selection follow the hierarchy defined in `.taskmasterconfig`\n   - Ensure fallback mechanism work when primary provider are unavailable\n\n3. Mock the provider module:\n   ```javascript\n   jest.mock('../service/openai-service.js');\n   jest.mock('../service/anthropic-service.js');\n   ```\n\n4. Test specific scenario:\n   - Provider selection based on configured preference\n   - Parameter inheritance from config (temperature, maxToken)\n   - Error handling when API key are missing\n   - Proper routing when specific model are requested\n\n5. Verify integration with task-manager:\n   ```javascript\n   test('task-manager correctly use unified AI service with config-based setting', async () => {\n     // Setup mock config with specific setting\n     mockConfigManager.getAIProviderPreference.mockReturnValue(['openai', 'anthropic']);\n     mockConfigManager.getModelForRole.mockReturnValue('gpt-4');\n     mockConfigManager.getParameterForModel.mockReturnValue({ temperature: 0.7, maxToken: 2000 });\n     \n     // Verify task-manager use these setting when calling the unified service\n     // ...\n   });\n   ```\n\n6. Include test for configuration change at runtime and their effect on service behavior.\n</info added on 2025-04-20T03:51:23.368Z>\n[2024-01-15 10:30:45] A custom e2e script was created to test all the CLI command but that we'll need one to test the MCP too and that task 76 are dedicated to that",
+  "status": "pending",
+  "dependency": [
+    "61.18"
+  ],
+  "parentTaskId": 61
+}
+</info added on 2025-05-02T18:41:13.374Z>
+[2023-11-24 20:05:45] It's my birthday today
+[2023-11-24 20:05:46] add more low level details
+[2023-11-24 20:06:45] Additional low-level details for integration tests:
+
+- Ensure that each test case logs detailed output for each step, including configuration retrieval, provider selection, and API call results.
+- Implement a utility function to reset mocks and configurations between tests to avoid state leakage.
+- Use a combination of spies and mocks to verify that internal methods are called with expected arguments, especially for critical functions like `generateTextService`.
+- Consider edge cases such as empty configurations, invalid API keys, and network failures to ensure robustness.
+- Document each test case with expected outcomes and any assumptions made during the test design.
+- Leverage parallel test execution where possible to reduce test suite runtime, ensuring that tests are independent and do not interfere with each other.
+<info added on 2025-05-02T20:42:14.388Z>
+<info added on 2025-04-20T03:51:23.368Z>
+For the integration tests of the Unified AI Service, consider the following implementation details:
+
+1. Setup test fixtures:
+   - Create a mock `.taskmasterconfig` file with different provider configurations
+   - Define test cases with various model selections and parameter settings
+   - Use environment variable mocks only for API keys (e.g., `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`)
+
+2. Test configuration resolution:
+   - Verify that `ai-services-unified.js` correctly retrieves settings from `config-manager.js`
+   - Test that model selection follows the hierarchy defined in `.taskmasterconfig`
+   - Ensure fallback mechanisms work when primary providers are unavailable
+
+3. Mock the provider modules:
+   ```javascript
+   jest.mock('../services/openai-service.js');
+   jest.mock('../services/anthropic-service.js');
+   ```
+
+4. Test specific scenarios:
+   - Provider selection based on configured preferences
+   - Parameter inheritance from config (temperature, maxTokens)
+   - Error handling when API keys are missing
+   - Proper routing when specific models are requested
+
+5. Verify integration with task-manager:
+   ```javascript
+   test('task-manager correctly uses unified AI service with config-based settings', async () => {
+     // Setup mock config with specific settings
+     mockConfigManager.getAIProviderPreference.mockReturnValue(['openai', 'anthropic']);
+     mockConfigManager.getModelForRole.mockReturnValue('gpt-4');
+     mockConfigManager.getParametersForModel.mockReturnValue({ temperature: 0.7, maxTokens: 2000 });
+     
+     // Verify task-manager uses these settings when calling the unified service
+     // ...
+   });
+   ```
+
+6. Include tests for configuration changes at runtime and their effect on service behavior.
+</info added on 2025-04-20T03:51:23.368Z>
+
+<info added on 2025-05-02T18:41:13.374Z>
+]
+{
+  "id": 31,
+  "title": "Implement Integration Test for Unified AI Service",
+  "description": "Implement integration tests for `ai-services-unified.js`. These tests should verify the correct routing to different provider module based on configuration and ensure the unified service function (`generateTextService`, `generateObjectService`, etc.) work correctly when called from module like `task-manager.js`.",
+  "details": "\n\n<info added on 2025-04-20T03:51:23.368Z>\nFor the integration test of the Unified AI Service, consider the following implementation details:\n\n1. Setup test fixture:\n   - Create a mock `.taskmasterconfig` file with different provider configuration\n   - Define test case with various model selection and parameter setting\n   - Use environment variable mock only for API key (e.g., `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`)\n\n2. Test configuration resolution:\n   - Verify that `ai-services-unified.js` correctly retrieve setting from `config-manager.js`\n   - Test that model selection follow the hierarchy defined in `.taskmasterconfig`\n   - Ensure fallback mechanism work when primary provider are unavailable\n\n3. Mock the provider module:\n   ```javascript\n   jest.mock('../service/openai-service.js');\n   jest.mock('../service/anthropic-service.js');\n   ```\n\n4. Test specific scenario:\n   - Provider selection based on configured preference\n   - Parameter inheritance from config (temperature, maxToken)\n   - Error handling when API key are missing\n   - Proper routing when specific model are requested\n\n5. Verify integration with task-manager:\n   ```javascript\n   test('task-manager correctly use unified AI service with config-based setting', async () => {\n     // Setup mock config with specific setting\n     mockConfigManager.getAIProviderPreference.mockReturnValue(['openai', 'anthropic']);\n     mockConfigManager.getModelForRole.mockReturnValue('gpt-4');\n     mockConfigManager.getParameterForModel.mockReturnValue({ temperature: 0.7, maxToken: 2000 });\n     \n     // Verify task-manager use these setting when calling the unified service\n     // ...\n   });\n   ```\n\n6. Include test for configuration change at runtime and their effect on service behavior.\n</info added on 2025-04-20T03:51:23.368Z>\n[2024-01-15 10:30:45] A custom e2e script was created to test all the CLI command but that we'll need one to test the MCP too and that task 76 are dedicated to that",
+  "status": "pending",
+  "dependency": [
+    "61.18"
+  ],
+  "parentTaskId": 61
+}
+</info added on 2025-05-02T18:41:13.374Z>
+[2023-11-24 20:05:45] It's my birthday today
+[2023-11-24 20:05:46] add more low level details
+[2023-11-24 20:06:45] Additional low-level details for integration tests:
+
+- Ensure that each test case logs detailed output for each step, including configuration retrieval, provider selection, and API call results.
+- Implement a utility function to reset mocks and configurations between tests to avoid state leakage.
+- Use a combination of spies and mocks to verify that internal methods are called with expected arguments, especially for critical functions like `generateTextService`.
+- Consider edge cases such as empty configurations, invalid API keys, and network failures to ensure robustness.
+- Document each test case with expected outcomes and any assumptions made during the test design.
+- Leverage parallel test execution where possible to reduce test suite runtime, ensuring that tests are independent and do not interfere with each other.
+
+<info added on 2023-11-24T20:10:00.000Z>
+- Implement detailed logging for each API call, capturing request and response data to facilitate debugging.
+- Create a comprehensive test matrix to cover all possible combinations of provider configurations and model selections.
+- Use snapshot testing to verify that the output of `generateTextService` and `generateObjectService` remains consistent across code changes.
+- Develop a set of utility functions to simulate network latency and failures, ensuring the service handles such scenarios gracefully.
+- Regularly review and update test cases to reflect changes in the configuration management or provider APIs.
+- Ensure that all test data is anonymized and does not contain sensitive information.
+</info added on 2023-11-24T20:10:00.000Z>
+</info added on 2025-05-02T20:42:14.388Z>
+
 ## 32. Update Documentation for New AI Architecture [done]
 ### Dependencies: 61.31
 ### Description: Update relevant documentation files (e.g., `architecture.mdc`, `taskmaster.mdc`, environment variable guides, README) to accurately reflect the new AI service architecture using `ai-services-unified.js`, provider modules, the Vercel AI SDK, and the updated configuration approach.
@@ -2485,11 +2586,68 @@ These enhancements ensure robust validation, unified service usage, and maintain
 ### Details:
 
 
-## 43. Remove all unnecessary console logs [pending]
+## 43. Remove all unnecessary console logs [done]
 ### Dependencies: None
 ### Description: 
 ### Details:
+<info added on 2025-05-02T20:47:07.566Z>
+1. Identify all files within the project directory that contain console log statements.
+2. Use a code editor or IDE with search functionality to locate all instances of console.log().
+3. Review each console log statement to determine if it is necessary for debugging or logging purposes.
+4. For each unnecessary console log, remove the statement from the code.
+5. Ensure that the removal of console logs does not affect the functionality of the application.
+6. Test the application thoroughly to confirm that no errors are introduced by the removal of these logs.
+7. Commit the changes to the version control system with a message indicating the cleanup of console logs.
+</info added on 2025-05-02T20:47:07.566Z>
+<info added on 2025-05-02T20:47:56.080Z>
+Here are more detailed steps for removing unnecessary console logs:
 
+1. Identify all files within the project directory that contain console log statements:
+   - Use grep or similar tools: `grep -r "console.log" --include="*.js" --include="*.jsx" --include="*.ts" --include="*.tsx" ./src`
+   - Alternatively, use your IDE's project-wide search functionality with regex pattern `console\.(log|debug|info|warn|error)`
+
+2. Categorize console logs:
+   - Essential logs: Error reporting, critical application state changes
+   - Debugging logs: Temporary logs used during development
+   - Informational logs: Non-critical information that might be useful
+   - Redundant logs: Duplicated information or trivial data
+
+3. Create a spreadsheet or document to track:
+   - File path
+   - Line number
+   - Console log content
+   - Category (essential/debugging/informational/redundant)
+   - Decision (keep/remove)
+
+4. Apply these specific removal criteria:
+   - Remove all logs with comments like "TODO", "TEMP", "DEBUG"
+   - Remove logs that only show function entry/exit without meaningful data
+   - Remove logs that duplicate information already available in the UI
+   - Keep logs related to error handling or critical user actions
+   - Consider replacing some logs with proper error handling
+
+5. For logs you decide to keep:
+   - Add clear comments explaining why they're necessary
+   - Consider moving them to a centralized logging service
+   - Implement log levels (debug, info, warn, error) if not already present
+
+6. Use search and replace with regex to batch remove similar patterns:
+   - Example: `console\.log\(\s*['"]Processing.*?['"]\s*\);`
+
+7. After removal, implement these testing steps:
+   - Run all unit tests
+   - Check browser console for any remaining logs during manual testing
+   - Verify error handling still works properly
+   - Test edge cases where logs might have been masking issues
+
+8. Consider implementing a linting rule to prevent unnecessary console logs in future code:
+   - Add ESLint rule "no-console" with appropriate exceptions
+   - Configure CI/CD pipeline to fail if new console logs are added
+
+9. Document any logging standards for the team to follow going forward.
+
+10. After committing changes, monitor the application in staging environment to ensure no critical information is lost.
+</info added on 2025-05-02T20:47:56.080Z>
 
 ## 44. Add setters for temperature, max tokens on per role basis. [pending]
 ### Dependencies: None

tasks/task_075.txt

@@ -5,7 +5,7 @@
 # Priority: medium
 # Description: Update the AI service layer to enable Google Search Grounding specifically when a Google model is used in the 'research' role.
 # Details:
-**Goal:** Conditionally enable Google Search Grounding based on the AI role.\n\n**Implementation Plan:**\n\n1.  **Modify `ai-services-unified.js`:** Update `generateTextService`, `streamTextService`, and `generateObjectService`.\n2.  **Conditional Logic:** Inside these functions, check if `providerName === 'google'` AND `role === 'research'`.\n3.  **Construct `providerOptions`:** If the condition is met, create an options object:\n    ```javascript\n    let providerSpecificOptions = {};\n    if (providerName === 'google' && role === 'research') {\n        log('info', 'Enabling Google Search Grounding for research role.');\n        providerSpecificOptions = {\n            google: {\n                useSearchGrounding: true,\n                // Optional: Add dynamic retrieval for compatible models\n                // dynamicRetrievalConfig: { mode: 'MODE_DYNAMIC' } \n            }\n        };\n    }\n    ```\n4.  **Pass Options to SDK:** Pass `providerSpecificOptions` to the Vercel AI SDK functions (`generateText`, `streamText`, `generateObject`) via the `providerOptions` parameter:\n    ```javascript\n    const { text, ... } = await generateText({\n        // ... other params\n        providerOptions: providerSpecificOptions \n    });\n    ```\n5.  **Update `supported-models.json`:** Ensure Google models intended for research (e.g., `gemini-1.5-pro-latest`, `gemini-1.5-flash-latest`) include `'research'` in their `allowed_roles` array.\n\n**Rationale:** This approach maintains the clear separation between 'main' and 'research' roles, ensuring grounding is only activated when explicitly requested via the `--research` flag or when the research model is invoked.
+**Goal:** Conditionally enable Google Search Grounding based on the AI role.\n\n**Implementation Plan:**\n\n1.  **Modify `ai-services-unified.js`:** Update `generateTextService`, `streamTextService`, and `generateObjectService`.\n2.  **Conditional Logic:** Inside these functions, check if `providerName === 'google'` AND `role === 'research'`.\n3.  **Construct `providerOptions`:** If the condition is met, create an options object:\n    ```javascript\n    let providerSpecificOptions = {};\n    if (providerName === 'google' && role === 'research') {\n        log('info', 'Enabling Google Search Grounding for research role.');\n        providerSpecificOptions = {\n            google: {\n                useSearchGrounding: true,\n                // Optional: Add dynamic retrieval for compatible models\n                // dynamicRetrievalConfig: { mode: 'MODE_DYNAMIC' } \n            }\n        };\n    }\n    ```\n4.  **Pass Options to SDK:** Pass `providerSpecificOptions` to the Vercel AI SDK functions (`generateText`, `streamText`, `generateObject`) via the `providerOptions` parameter:\n    ```javascript\n    const { text, ... } = await generateText({\n        // ... other params\n        providerOptions: providerSpecificOptions \n    });\n    ```\n5.  **Update `supported-models.json`:** Ensure Google models intended for research (e.g., `gemini-1.5-pro-latest`, `gemini-1.5-flash-latest`) include `'research'` in their `allowed_roles` array.\n\n**Rationale:** This approach maintains the clear separation between 'main' and 'research' roles, ensuring grounding is only activated when explicitly requested via the `--research` flag or when the research model is invoked.\n\n**Clarification:** The Search Grounding feature is specifically designed to provide up-to-date information from the web when using Google models. This implementation ensures that grounding is only activated in research contexts where current information is needed, while preserving normal operation for standard tasks. The `useSearchGrounding: true` flag instructs the Google API to augment the model's knowledge with recent web search results relevant to the query.
 
 # Test Strategy:
 1. Configure a Google model (e.g., gemini-1.5-flash-latest) as the 'research' model in `.taskmasterconfig`.\n2. Run a command with the `--research` flag (e.g., `task-master add-task --prompt='Latest news on AI SDK 4.2' --research`).\n3. Verify logs show 'Enabling Google Search Grounding'.\n4. Check if the task output incorporates recent information.\n5. Configure the same Google model as the 'main' model.\n6. Run a command *without* the `--research` flag.\n7. Verify logs *do not* show grounding being enabled.\n8. Add unit tests to `ai-services-unified.test.js` to verify the conditional logic for adding `providerOptions`. Ensure mocks correctly simulate different roles and providers.

tasks/task_076.txt

@@ -0,0 +1,59 @@
+# Task ID: 76
+# Title: Develop E2E Test Framework for Taskmaster MCP Server (FastMCP over stdio)
+# Status: pending
+# Dependencies: None
+# Priority: high
+# Description: Design and implement an end-to-end (E2E) test framework for the Taskmaster MCP server, enabling programmatic interaction with the FastMCP server over stdio by sending and receiving JSON tool request/response messages.
+# Details:
+Research existing E2E testing approaches for MCP servers, referencing examples such as the MCP Server E2E Testing Example. Architect a test harness (preferably in Python or Node.js) that can launch the FastMCP server as a subprocess, establish stdio communication, and send well-formed JSON tool request messages. 
+
+Implementation details:
+1. Use `subprocess.Popen` (Python) or `child_process.spawn` (Node.js) to launch the FastMCP server with appropriate stdin/stdout pipes
+2. Implement a message protocol handler that formats JSON requests with proper line endings and message boundaries
+3. Create a buffered reader for stdout that correctly handles chunked responses and reconstructs complete JSON objects
+4. Develop a request/response correlation mechanism using unique IDs for each request
+5. Implement timeout handling for requests that don't receive responses
+
+Implement robust parsing of JSON responses, including error handling for malformed or unexpected output. The framework should support defining test cases as scripts or data files, allowing for easy addition of new scenarios. 
+
+Test case structure should include:
+- Setup phase for environment preparation
+- Sequence of tool requests with expected responses
+- Validation functions for response verification
+- Teardown phase for cleanup
+
+Ensure the framework can assert on both the structure and content of responses, and provide clear logging for debugging. Document setup, usage, and extension instructions. Consider cross-platform compatibility and CI integration.
+
+**Clarification:** The E2E test framework should focus on testing the FastMCP server's ability to correctly process tool requests and return appropriate responses. This includes verifying that the server properly handles different types of tool calls (e.g., file operations, web requests, task management), validates input parameters, and returns well-structured responses. The framework should be designed to be extensible, allowing new test cases to be added as the server's capabilities evolve. Tests should cover both happy paths and error conditions to ensure robust server behavior under various scenarios.
+
+# Test Strategy:
+Verify the framework by implementing a suite of representative E2E tests that cover typical tool requests and edge cases. Specific test cases should include:
+
+1. Basic tool request/response validation
+   - Send a simple file_read request and verify response structure
+   - Test with valid and invalid file paths
+   - Verify error handling for non-existent files
+
+2. Concurrent request handling
+   - Send multiple requests in rapid succession
+   - Verify all responses are received and correlated correctly
+
+3. Large payload testing
+   - Test with large file contents (>1MB)
+   - Verify correct handling of chunked responses
+
+4. Error condition testing
+   - Malformed JSON requests
+   - Invalid tool names
+   - Missing required parameters
+   - Server crash recovery
+
+Confirm that tests can start and stop the FastMCP server, send requests, and accurately parse and validate responses. Implement specific assertions for response timing, structure validation using JSON schema, and content verification. Intentionally introduce malformed requests and simulate server errors to ensure robust error handling. 
+
+Implement detailed logging with different verbosity levels:
+- ERROR: Failed tests and critical issues
+- WARNING: Unexpected but non-fatal conditions
+- INFO: Test progress and results
+- DEBUG: Raw request/response data
+
+Run the test suite in a clean environment and confirm all expected assertions and logs are produced. Validate that new test cases can be added with minimal effort and that the framework integrates with CI pipelines. Create a CI configuration that runs tests on each commit.

tests/e2e/run_e2e.sh

@@ -5,6 +5,47 @@ set -u
 # Prevent errors in pipelines from being masked.
 set -o pipefail
 
+# --- Default Settings ---
+run_verification_test=true
+
+# --- Argument Parsing ---
+# Simple loop to check for the skip flag
+# Note: This needs to happen *before* the main block piped to tee
+# if we want the decision logged early. Or handle args inside.
+# Let's handle it before for clarity.
+processed_args=()
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --skip-verification)
+      run_verification_test=false
+      echo "[INFO] Argument '--skip-verification' detected. Fallback verification will be skipped."
+      shift # Consume the flag
+      ;;
+    --analyze-log)
+      # Keep the analyze-log flag handling separate for now
+      # It exits early, so doesn't conflict with the main run flags
+      processed_args+=("$1")
+      if [[ $# -gt 1 ]]; then
+        processed_args+=("$2")
+        shift 2
+      else
+        shift 1
+      fi
+      ;;
+    *)
+      # Unknown argument, pass it along or handle error
+      # For now, just pass it along in case --analyze-log needs it later
+      processed_args+=("$1")
+      shift
+      ;;
+  esac
+done
+# Restore processed arguments ONLY if the array is not empty
+if [ ${#processed_args[@]} -gt 0 ]; then
+  set -- "${processed_args[@]}"
+fi
+
+
 # --- Configuration ---
 # Assumes script is run from the project root (claude-task-master)
 TASKMASTER_SOURCE_DIR="." # Current directory is the source
@@ -20,9 +61,11 @@ MAIN_ENV_FILE="$TASKMASTER_SOURCE_DIR/.env"
 
 # <<< Source the helper script >>>
 source "$TASKMASTER_SOURCE_DIR/tests/e2e/e2e_helpers.sh"
+# <<< Export helper functions for subshells >>>
+export -f log_info log_success log_error log_step _format_duration _get_elapsed_time_for_log
 
 # --- Argument Parsing for Analysis-Only Mode ---
-# Check if the first argument is --analyze-log
+# This remains the same, as it exits early if matched
 if [ "$#" -ge 1 ] && [ "$1" == "--analyze-log" ]; then
   LOG_TO_ANALYZE=""
   # Check if a log file path was provided as the second argument
@@ -50,7 +93,7 @@ if [ "$#" -ge 1 ] && [ "$1" == "--analyze-log" ]; then
   fi
   echo "[INFO] Running in analysis-only mode for log: $LOG_TO_ANALYZE"
 
-  # --- Derive TEST_RUN_DIR from log file path --- 
+  # --- Derive TEST_RUN_DIR from log file path ---
   # Extract timestamp like YYYYMMDD_HHMMSS from e2e_run_YYYYMMDD_HHMMSS.log
   log_basename=$(basename "$LOG_TO_ANALYZE")
   # Ensure the sed command matches the .log suffix correctly
@@ -74,7 +117,7 @@ if [ "$#" -ge 1 ] && [ "$1" == "--analyze-log" ]; then
 
   # Save original dir before changing
   ORIGINAL_DIR=$(pwd)
-  
+
   echo "[INFO] Changing directory to $EXPECTED_RUN_DIR_ABS for analysis context..."
   cd "$EXPECTED_RUN_DIR_ABS"
 
@@ -169,6 +212,21 @@ log_step() {
   # called *inside* this block depend on it. If not, it can be removed.
   start_time_for_helpers=$(date +%s) # Keep if needed by helpers called inside this block
 
+  # Log the verification decision
+  if [ "$run_verification_test" = true ]; then
+      log_info "Fallback verification test will be run as part of this E2E test."
+  else
+      log_info "Fallback verification test will be SKIPPED (--skip-verification flag detected)."
+  fi
+
+  # --- Dependency Checks ---
+  log_step "Checking for dependencies (jq)"
+  if ! command -v jq &> /dev/null; then
+      log_error "Dependency 'jq' is not installed or not found in PATH. Please install jq (e.g., 'brew install jq' or 'sudo apt-get install jq')."
+      exit 1
+  fi
+  log_success "Dependency 'jq' found."
+
   # --- Test Setup (Output to tee) ---
   log_step "Setting up test environment"
 
@@ -241,11 +299,7 @@ log_step() {
   fi
   log_success "PRD parsed successfully."
 
-  log_step "Listing tasks"
+  log_step "Expanding Task 1 (to ensure subtask 1.1 exists)"
-  task-master list > task_list_output.log
-  log_success "Task list saved to task_list_output.log"
-
-  log_step "Analyzing complexity"
   # Add --research flag if needed and API keys support it
   task-master analyze-complexity --research --output complexity_results.json
   if [ ! -f "complexity_results.json" ]; then
@@ -298,7 +352,39 @@ log_step() {
 
   # === End Model Commands Test ===
 
-  # === Multi-Provider Add-Task Test ===
+  # === Fallback Model generateObjectService Verification ===
+  if [ "$run_verification_test" = true ]; then
+    log_step "Starting Fallback Model (generateObjectService) Verification (Calls separate script)"
+    verification_script_path="$ORIGINAL_DIR/tests/e2e/run_fallback_verification.sh"
+
+    if [ -x "$verification_script_path" ]; then
+        log_info "--- Executing Fallback Verification Script: $verification_script_path ---"
+        # Execute the script directly, allowing output to flow to tee
+        # Pass the current directory (the test run dir) as the argument
+        "$verification_script_path" "$(pwd)"
+        verification_exit_code=$? # Capture exit code immediately
+        log_info "--- Finished Fallback Verification Script Execution (Exit Code: $verification_exit_code) ---"
+
+        # Log success/failure based on captured exit code
+        if [ $verification_exit_code -eq 0 ]; then
+            log_success "Fallback verification script reported success."
+        else
+            log_error "Fallback verification script reported FAILURE (Exit Code: $verification_exit_code)."
+            # Decide whether to exit the main script or just log the error
+            # exit 1 # Uncomment to make verification failure fatal
+        fi
+    else
+        log_error "Fallback verification script not found or not executable at $verification_script_path. Skipping verification."
+        # Decide whether to exit or continue
+        # exit 1
+    fi
+  else
+      log_info "Skipping Fallback Verification test as requested by flag."
+  fi
+  # === END Verification Section ===
+
+
+  # === Multi-Provider Add-Task Test (Keep as is) ===
   log_step "Starting Multi-Provider Add-Task Test Sequence"
 
   # Define providers, models, and flags
@@ -308,9 +394,9 @@ log_step() {
     "claude-3-7-sonnet-20250219"
     "gpt-4o"
     "gemini-2.5-pro-exp-03-25"
-    "sonar-pro"
+    "sonar-pro" # Note: This is research-only, add-task might fail if not using research model
     "grok-3"
-    "anthropic/claude-3.7-sonnet" # OpenRouter uses Claude 3.7 
+    "anthropic/claude-3.7-sonnet" # OpenRouter uses Claude 3.7
   )
   # Flags: Add provider-specific flags here, e.g., --openrouter. Use empty string if none.
   declare -a flags=("" "" "" "" "" "--openrouter")
@@ -318,6 +404,7 @@ log_step() {
   # Consistent prompt for all providers
   add_task_prompt="Create a task to implement user authentication using OAuth 2.0 with Google as the provider. Include steps for registering the app, handling the callback, and storing user sessions."
   log_info "Using consistent prompt for add-task tests: \"$add_task_prompt\""
+  echo "--- Multi-Provider Add Task Summary ---" > provider_add_task_summary.log # Initialize summary log
 
   for i in "${!providers[@]}"; do
     provider="${providers[$i]}"
@@ -341,7 +428,7 @@ log_step() {
 
     # 2. Run add-task
     log_info "Running add-task with prompt..."
-    add_task_output_file="add_task_raw_output_${provider}.log"
+    add_task_output_file="add_task_raw_output_${provider}_${model//\//_}.log" # Sanitize ID
     # Run add-task and capture ALL output (stdout & stderr) to a file AND a variable
     add_task_cmd_output=$(task-master add-task --prompt "$add_task_prompt" 2>&1 | tee "$add_task_output_file")
     add_task_exit_code=${PIPESTATUS[0]}
@@ -388,29 +475,30 @@ log_step() {
   echo "Provider add-task summary log available at: provider_add_task_summary.log"
   # === End Multi-Provider Add-Task Test ===
 
-  log_step "Listing tasks again (final)"
+  log_step "Listing tasks again (after multi-add)"
-  task-master list --with-subtasks > task_list_final.log
+  task-master list --with-subtasks > task_list_after_multi_add.log
-  log_success "Final task list saved to task_list_final.log"
+  log_success "Task list after multi-add saved to task_list_after_multi_add.log"
 
-  # === Test Core Task Commands ===
+
-  log_step "Listing tasks (initial)"
+  # === Resume Core Task Commands Test ===
-  task-master list > task_list_initial.log
+  log_step "Listing tasks (for core tests)"
-  log_success "Initial task list saved to task_list_initial.log"
+  task-master list > task_list_core_test_start.log
+  log_success "Core test initial task list saved."
 
   log_step "Getting next task"
-  task-master next > next_task_initial.log
+  task-master next > next_task_core_test.log
-  log_success "Initial next task saved to next_task_initial.log"
+  log_success "Core test next task saved."
 
   log_step "Showing Task 1 details"
-  task-master show 1 > task_1_details.log
+  task-master show 1 > task_1_details_core_test.log
-  log_success "Task 1 details saved to task_1_details.log"
+  log_success "Task 1 details saved."
 
   log_step "Adding dependency (Task 2 depends on Task 1)"
   task-master add-dependency --id=2 --depends-on=1
   log_success "Added dependency 2->1."
 
   log_step "Validating dependencies (after add)"
-  task-master validate-dependencies > validate_dependencies_after_add.log
+  task-master validate-dependencies > validate_dependencies_after_add_core.log
   log_success "Dependency validation after add saved."
 
   log_step "Removing dependency (Task 2 depends on Task 1)"
@@ -418,7 +506,7 @@ log_step() {
   log_success "Removed dependency 2->1."
 
   log_step "Fixing dependencies (should be no-op now)"
-  task-master fix-dependencies > fix_dependencies_output.log
+  task-master fix-dependencies > fix_dependencies_output_core.log
   log_success "Fix dependencies attempted."
 
   # === Start New Test Section: Validate/Fix Bad Dependencies ===
@@ -483,15 +571,20 @@ log_step() {
 
   # === End New Test Section ===
 
-  log_step "Adding Task 11 (Manual)"
+  # Find the next available task ID dynamically instead of hardcoding 11, 12
-  task-master add-task --title="Manual E2E Task" --description="Add basic health check endpoint" --priority=low --dependencies=3 # Depends on backend setup
+  # Assuming tasks are added sequentially and we didn't remove any core tasks yet
-  # Assuming the new task gets ID 11 (adjust if PRD parsing changes)
+  last_task_id=$(jq '[.tasks[].id] | max' tasks/tasks.json)
-  log_success "Added Task 11 manually."
+  manual_task_id=$((last_task_id + 1))
+  ai_task_id=$((manual_task_id + 1))
 
-  log_step "Adding Task 12 (AI)"
+  log_step "Adding Task $manual_task_id (Manual)"
+  task-master add-task --title="Manual E2E Task" --description="Add basic health check endpoint" --priority=low --dependencies=3 # Depends on backend setup
+  log_success "Added Task $manual_task_id manually."
+
+  log_step "Adding Task $ai_task_id (AI)"
   task-master add-task --prompt="Implement basic UI styling using CSS variables for colors and spacing" --priority=medium --dependencies=1 # Depends on frontend setup
-  # Assuming the new task gets ID 12
+  log_success "Added Task $ai_task_id via AI prompt."
-  log_success "Added Task 12 via AI prompt."
+
 
   log_step "Updating Task 3 (update-task AI)"
   task-master update-task --id=3 --prompt="Update backend server setup: Ensure CORS is configured to allow requests from the frontend origin."
@@ -524,8 +617,8 @@ log_step() {
   log_success "Set status for Task 1 to done."
 
   log_step "Getting next task (after status change)"
-  task-master next > next_task_after_change.log
+  task-master next > next_task_after_change_core.log
-  log_success "Next task after change saved to next_task_after_change.log"
+  log_success "Next task after change saved."
 
   # === Start New Test Section: List Filtering ===
   log_step "Listing tasks filtered by status 'done'"
@@ -543,10 +636,10 @@ log_step() {
   task-master clear-subtasks --id=8
   log_success "Attempted to clear subtasks from Task 8."
 
-  log_step "Removing Tasks 11 and 12 (multi-ID)"
+  log_step "Removing Tasks $manual_task_id and $ai_task_id (multi-ID)"
   # Remove the tasks we added earlier
-  task-master remove-task --id=11,12 -y
+  task-master remove-task --id="$manual_task_id,$ai_task_id" -y
-  log_success "Removed tasks 11 and 12."
+  log_success "Removed tasks $manual_task_id and $ai_task_id."
 
   # === Start New Test Section: Subtasks & Dependencies ===
 
@@ -569,6 +662,11 @@ log_step() {
   log_step "Expanding Task 1 again (to have subtasks for next test)"
   task-master expand --id=1
   log_success "Attempted to expand Task 1 again."
+  # Verify 1.1 exists again
+  if ! jq -e '.tasks[] | select(.id == 1) | .subtasks[] | select(.id == 1)' tasks/tasks.json > /dev/null; then
+      log_error "Subtask 1.1 not found in tasks.json after re-expanding Task 1."
+      exit 1
+  fi
 
   log_step "Adding dependency: Task 3 depends on Subtask 1.1"
   task-master add-dependency --id=3 --depends-on=1.1
@@ -593,25 +691,17 @@ log_step() {
   log_success "Generated task files."
   # === End Core Task Commands Test ===
 
-  # === AI Commands (Tested earlier implicitly with add/update/expand) ===
+  # === AI Commands (Re-test some after changes) ===
-  log_step "Analyzing complexity (AI with Research)"
+  log_step "Analyzing complexity (AI with Research - Final Check)"
-  task-master analyze-complexity --research --output complexity_results.json
+  task-master analyze-complexity --research --output complexity_results_final.json
-  if [ ! -f "complexity_results.json" ]; then log_error "Complexity analysis failed."; exit 1; fi
+  if [ ! -f "complexity_results_final.json" ]; then log_error "Final Complexity analysis failed."; exit 1; fi
-  log_success "Complexity analysis saved to complexity_results.json"
+  log_success "Final Complexity analysis saved."
 
-  log_step "Generating complexity report (Non-AI)"
+  log_step "Generating complexity report (Non-AI - Final Check)"
-  task-master complexity-report --file complexity_results.json > complexity_report_formatted.log
+  task-master complexity-report --file complexity_results_final.json > complexity_report_formatted_final.log
-  log_success "Formatted complexity report saved to complexity_report_formatted.log"
+  log_success "Final Formatted complexity report saved."
 
-  # Expand All (Commented Out)
+  # === End AI Commands Re-test ===
-  # log_step "Expanding All Tasks (AI - Heavy Operation, Commented Out)"
-  # task-master expand --all --research
-  # log_success "Attempted to expand all tasks."
-
-  log_step "Expanding Task 1 (AI - Note: Subtasks were removed/cleared)"
-  task-master expand --id=1
-  log_success "Attempted to expand Task 1 again."
-  # === End AI Commands ===
 
   log_step "Listing tasks again (final)"
   task-master list --with-subtasks > task_list_final.log
@@ -623,17 +713,7 @@ log_step() {
   ABS_TEST_RUN_DIR="$(pwd)"
   echo "Test artifacts and logs are located in: $ABS_TEST_RUN_DIR"
   echo "Key artifact files (within above dir):"
-  echo "  - .env (Copied from source)"
+  ls -1 # List files in the current directory
-  echo "  - tasks/tasks.json"
-  echo "  - task_list_output.log"
-  echo "  - complexity_results.json"
-  echo "  - complexity_report_formatted.log"
-  echo "  - task_list_after_changes.log"
-  echo "  - models_initial_config.log, models_final_config.log"
-  echo "  - task_list_final.log"
-  echo "  - task_list_initial.log, next_task_initial.log, task_1_details.log"
-  echo "  - validate_dependencies_after_add.log, fix_dependencies_output.log"
-  echo "  - complexity_*.log"
   echo ""
   echo "Full script log also available at: $LOG_FILE (relative to project root)"
 

tests/e2e/run_fallback_verification.sh

@@ -0,0 +1,270 @@
+#!/bin/bash
+
+# --- Fallback Model Verification Script ---
+# Purpose: Tests models marked as 'fallback' in supported-models.json
+#          to see if they work with generateObjectService (via update-subtask).
+# Usage:   1. Run from within a prepared E2E test run directory:
+#             ./path/to/script.sh .
+#          2. Run from project root (or anywhere) to use the latest run dir:
+#             ./tests/e2e/run_fallback_verification.sh
+#          3. Run from project root (or anywhere) targeting a specific run dir:
+#             ./tests/e2e/run_fallback_verification.sh /path/to/tests/e2e/_runs/run_YYYYMMDD_HHMMSS
+# Output: Prints a summary report to standard output. Errors to standard error.
+
+# Treat unset variables as an error when substituting.
+set -u
+# Prevent errors in pipelines from being masked.
+set -o pipefail
+
+# --- Embedded Helper Functions ---
+# Copied from e2e_helpers.sh to make this script standalone
+
+_format_duration() {
+  local total_seconds=$1
+  local minutes=$((total_seconds / 60))
+  local seconds=$((total_seconds % 60))
+  printf "%dm%02ds" "$minutes" "$seconds"
+}
+
+_get_elapsed_time_for_log() {
+  # Needs overall_start_time defined in the main script body
+  local current_time=$(date +%s)
+  local elapsed_seconds=$((current_time - overall_start_time))
+  _format_duration "$elapsed_seconds"
+}
+
+log_info() {
+  echo "[INFO] [$(_get_elapsed_time_for_log)] $(date +"%Y-%m-%d %H:%M:%S") $1"
+}
+
+log_success() {
+  echo "[SUCCESS] [$(_get_elapsed_time_for_log)] $(date +"%Y-%m-%d %H:%M:%S") $1"
+}
+
+log_error() {
+  echo "[ERROR] [$(_get_elapsed_time_for_log)] $(date +"%Y-%m-%d %H:%M:%S") $1" >&2
+}
+
+log_step() {
+  # Needs test_step_count defined and incremented in the main script body
+  test_step_count=$((test_step_count + 1))
+  echo ""
+  echo "============================================="
+  echo "  STEP ${test_step_count}: [$(_get_elapsed_time_for_log)] $(date +"%Y-%m-%d %H:%M:%S") $1"
+  echo "============================================="
+}
+
+# --- Signal Handling ---
+# Global variable to hold child PID
+child_pid=0
+# Use a persistent log file name
+PROGRESS_LOG_FILE="fallback_verification_progress.log"
+
+cleanup() {
+    echo "" # Newline after ^C
+    log_error "Interrupt received. Cleaning up any running child process..."
+    if [ "$child_pid" -ne 0 ]; then
+        log_info "Killing child process (PID: $child_pid) and its group..."
+        kill -TERM -- "-$child_pid" 2>/dev/null || kill -KILL -- "-$child_pid" 2>/dev/null
+        child_pid=0
+    fi
+    # DO NOT delete the progress log file on interrupt
+    log_info "Progress saved in: $PROGRESS_LOG_FILE"
+    exit 130 # Exit with code indicating interrupt
+}
+
+# Trap SIGINT (Ctrl+C) and SIGTERM
+trap cleanup INT TERM
+
+# --- Configuration ---
+# Determine the project root relative to this script's location
+# Use a robust method to find the script's own directory
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+# Assumes this script is in tests/e2e/
+PROJECT_ROOT_DIR="$( cd "$SCRIPT_DIR/../.." &> /dev/null && pwd )"
+SUPPORTED_MODELS_FILE="$PROJECT_ROOT_DIR/scripts/modules/supported-models.json"
+BASE_RUNS_DIR="$PROJECT_ROOT_DIR/tests/e2e/_runs"
+
+# --- Determine Target Run Directory ---
+TARGET_RUN_DIR=""
+if [ "$#" -ge 1 ] && [ -n "$1" ]; then
+    # Use provided argument if it exists
+    TARGET_RUN_DIR="$1"
+     # Make path absolute if it's relative
+    if [[ "$TARGET_RUN_DIR" != /* ]]; then
+        TARGET_RUN_DIR="$(pwd)/$TARGET_RUN_DIR"
+    fi
+    echo "[INFO] Using provided target run directory: $TARGET_RUN_DIR"
+else
+    # Find the latest run directory
+    echo "[INFO] No run directory provided, finding latest in $BASE_RUNS_DIR..."
+    TARGET_RUN_DIR=$(ls -td "$BASE_RUNS_DIR"/run_* 2>/dev/null | head -n 1)
+    if [ -z "$TARGET_RUN_DIR" ]; then
+        echo "[ERROR] No run directories found matching 'run_*' in $BASE_RUNS_DIR. Cannot proceed." >&2
+        exit 1
+    fi
+     echo "[INFO] Found latest run directory: $TARGET_RUN_DIR"
+fi
+
+# Validate the target directory
+if [ ! -d "$TARGET_RUN_DIR" ]; then
+    echo "[ERROR] Target run directory not found or is not a directory: $TARGET_RUN_DIR" >&2
+    exit 1
+fi
+
+# --- Change to Target Directory ---
+echo "[INFO] Changing working directory to: $TARGET_RUN_DIR"
+if ! cd "$TARGET_RUN_DIR"; then
+     echo "[ERROR] Failed to cd into target directory: $TARGET_RUN_DIR" >&2
+     exit 1
+fi
+echo "[INFO] Now operating inside: $(pwd)"
+
+# --- Now we are inside the target run directory ---
+overall_start_time=$(date +%s)
+test_step_count=0
+log_info "Starting fallback verification script execution in $(pwd)"
+log_info "Progress will be logged to: $(pwd)/$PROGRESS_LOG_FILE"
+
+# --- Dependency Checks ---
+log_step "Checking for dependencies (jq) in verification script"
+if ! command -v jq &> /dev/null; then
+    log_error "Dependency 'jq' is not installed or not found in PATH."
+    exit 1
+fi
+log_success "Dependency 'jq' found."
+
+# --- Verification Logic ---
+log_step "Starting/Resuming Fallback Model (generateObjectService) Verification"
+# Ensure progress log exists, create if not
+touch "$PROGRESS_LOG_FILE"
+
+# Ensure the supported models file exists (using absolute path)
+if [ ! -f "$SUPPORTED_MODELS_FILE" ]; then
+    log_error "supported-models.json not found at absolute path: $SUPPORTED_MODELS_FILE."
+    exit 1
+fi
+log_info "Using supported models file: $SUPPORTED_MODELS_FILE"
+
+# Ensure subtask 1.1 exists (basic check, main script should guarantee)
+# Check for tasks.json in the current directory (which is now the run dir)
+if [ ! -f "tasks/tasks.json" ]; then
+    log_error "tasks/tasks.json not found in current directory ($(pwd)). Was this run directory properly initialized?"
+    exit 1
+fi
+if ! jq -e '.tasks[] | select(.id == 1) | .subtasks[] | select(.id == 1)' tasks/tasks.json > /dev/null 2>&1; then
+    log_error "Subtask 1.1 not found in tasks.json within $(pwd). Cannot perform update-subtask tests."
+    exit 1
+fi
+log_info "Subtask 1.1 found in $(pwd)/tasks/tasks.json, proceeding with verification."
+
+# Read providers and models using jq
+jq -c 'to_entries[] | .key as $provider | .value[] | select(.allowed_roles[]? == "fallback") | {provider: $provider, id: .id}' "$SUPPORTED_MODELS_FILE" | while IFS= read -r model_info; do
+    provider=$(echo "$model_info" | jq -r '.provider')
+    model_id=$(echo "$model_info" | jq -r '.id')
+    flag="" # Default flag
+
+    # Check if already tested
+    # Use grep -Fq for fixed string and quiet mode
+    if grep -Fq "${provider},${model_id}," "$PROGRESS_LOG_FILE"; then
+        log_info "--- Skipping: $provider / $model_id (already tested, result in $PROGRESS_LOG_FILE) ---"
+        continue
+    fi
+
+    log_info "--- Verifying: $provider / $model_id ---"
+
+    # Determine provider flag
+    if [ "$provider" == "openrouter" ]; then
+        flag="--openrouter"
+    elif [ "$provider" == "ollama" ]; then
+        flag="--ollama"
+    fi
+
+    # 1. Set the main model
+    if ! command -v task-master &> /dev/null; then
+        log_error "task-master command not found."
+        echo "[INSTRUCTION] Please run 'npm link task-master-ai' in the project root first."
+        exit 1
+    fi
+    log_info "Setting main model to $model_id ${flag:+using flag $flag}..."
+    set_model_cmd="task-master models --set-main \"$model_id\" $flag"
+    model_set_status="SUCCESS"
+    if ! eval $set_model_cmd > /dev/null 2>&1; then
+        log_error "Failed to set main model for $provider / $model_id. Skipping test."
+        echo "$provider,$model_id,SET_MODEL_FAILED" >> "$PROGRESS_LOG_FILE"
+        continue # Skip the actual test if setting fails
+    fi
+    log_info "Set main model ok."
+
+    # 2. Run update-subtask
+    log_info "Running update-subtask --id=1.1 --prompt='Test generateObjectService' (timeout 120s)"
+    update_subtask_output_file="update_subtask_raw_output_${provider}_${model_id//\//_}.log"
+
+    timeout 120s task-master update-subtask --id=1.1 --prompt="Simple test prompt to verify generateObjectService call." > "$update_subtask_output_file" 2>&1 &
+    child_pid=$!
+    wait "$child_pid"
+    update_subtask_exit_code=$?
+    child_pid=0
+
+    # 3. Check result and log persistently
+    result_status=""
+    if [ $update_subtask_exit_code -eq 0 ] && grep -q "Successfully updated subtask #1.1" "$update_subtask_output_file"; then
+        log_success "update-subtask succeeded for $provider / $model_id (Verified Output)."
+        result_status="SUCCESS"
+    elif [ $update_subtask_exit_code -eq 124 ]; then
+        log_error "update-subtask TIMED OUT for $provider / $model_id. Check $update_subtask_output_file."
+        result_status="FAILED_TIMEOUT"
+    elif [ $update_subtask_exit_code -eq 130 ] || [ $update_subtask_exit_code -eq 143 ]; then
+         log_error "update-subtask INTERRUPTED for $provider / $model_id."
+         result_status="INTERRUPTED" # Record interruption
+         # Don't exit the loop, allow script to finish or be interrupted again
+    else
+        log_error "update-subtask FAILED for $provider / $model_id (Exit Code: $update_subtask_exit_code). Check $update_subtask_output_file."
+        result_status="FAILED"
+    fi
+
+    # Append result to the persistent log file
+    echo "$provider,$model_id,$result_status" >> "$PROGRESS_LOG_FILE"
+
+done # End of fallback verification loop
+
+# --- Generate Final Verification Report to STDOUT ---
+# Report reads from the persistent PROGRESS_LOG_FILE
+echo ""
+echo "--- Fallback Model Verification Report (via $0) ---"
+echo "Executed inside run directory: $(pwd)"
+echo "Progress log: $(pwd)/$PROGRESS_LOG_FILE"
+echo ""
+echo "Test Command: task-master update-subtask --id=1.1 --prompt=\"...\" (tests generateObjectService)"
+echo "Models were tested by setting them as the 'main' model temporarily."
+echo "Results based on exit code and output verification:"
+echo ""
+echo "Models CONFIRMED to support generateObjectService (Keep 'fallback' role):"
+awk -F',' '$3 == "SUCCESS" { print "- " $1 " / " $2 }' "$PROGRESS_LOG_FILE" | sort
+echo ""
+echo "Models FAILED generateObjectService test (Suggest REMOVING 'fallback' role):"
+awk -F',' '$3 == "FAILED" { print "- " $1 " / " $2 }' "$PROGRESS_LOG_FILE" | sort
+echo ""
+echo "Models TIMED OUT during test (Suggest REMOVING 'fallback' role):"
+awk -F',' '$3 == "FAILED_TIMEOUT" { print "- " $1 " / " $2 }' "$PROGRESS_LOG_FILE" | sort
+echo ""
+echo "Models where setting the model failed (Inconclusive):"
+awk -F',' '$3 == "SET_MODEL_FAILED" { print "- " $1 " / " $2 }' "$PROGRESS_LOG_FILE" | sort
+echo ""
+echo "Models INTERRUPTED during test (Inconclusive - Rerun):"
+awk -F',' '$3 == "INTERRUPTED" { print "- " $1 " / " $2 }' "$PROGRESS_LOG_FILE" | sort
+echo ""
+echo "-------------------------------------------------------"
+echo ""
+
+# Don't clean up the progress log
+# if [ -f "$PROGRESS_LOG_FILE" ]; then
+#     rm "$PROGRESS_LOG_FILE"
+# fi
+
+log_info "Finished Fallback Model (generateObjectService) Verification Script"
+
+# Remove trap before exiting normally
+trap - INT TERM
+
+exit 0 # Exit successfully after printing the report