feat: add new bin task-master-ai same name as package to allow npx -y task-master-ai to work

Closes #241 #211 #184 #193

.changeset/all-parks-sort.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-- Fix expand-all command bugs that caused NaN errors with --all option and JSON formatting errors with research enabled. Improved error handling to provide clear feedback when subtask generation fails, including task IDs and actionable suggestions.

.changeset/brave-doors-open.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Ensures add-task also has manual creation flags like --title/-t, --description/-d etc.

.changeset/brave-seas-pull.md

@@ -0,0 +1,6 @@
+---
+'task-master-ai': patch
+---
+
+- Fixes shebang issue not allowing task-master to run on certain windows operating systems
+- Resolves #241 #211 #184 #193

.changeset/chubby-moose-stay.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Updates the parameter descriptions for update, update-task and update-subtask to ensure the MCP server correctly reaches for the right update command based on what is being updated -- all tasks, one task, or a subtask.

.changeset/fifty-squids-wear.md

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

.changeset/happy-snails-train.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-fix threshold parameter validation and testing for analyze-complexity.

.changeset/polite-candles-follow.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': minor
+---
+
+Add `npx task-master-ai` that runs mcp instead of using `task-master-mcp``

.changeset/red-lights-mix.md

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

.changeset/silly-horses-grin.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Adjusts the taskmaster.mdc rules for init and parse-prd so the LLM correctly reaches for the next steps rather than trying to reinitialize or access tasks not yet created until PRD has been parsed."

.changeset/thirty-items-kiss.md

@@ -1,11 +0,0 @@
----
-'task-master-ai': patch
----
-
-Two improvements to MCP tools:
-
-1. Adjusts the response sent to the MCP client for `initialize-project` tool so it includes an explicit `next_steps` object. This is in an effort to reduce variability in what the LLM chooses to do as soon as the confirmation of initialized project. Instead of arbitrarily looking for tasks, it will know that a PRD is required next and will steer the user towards that before reaching for the parse-prd command.
-
-2. Updates the `parse_prd` tool parameter description to explicitly mention support for .md file formats, clarifying that users can provide PRD documents in various text formats including Markdown.
-
-3. Updates the `parse_prd` tool `numTasks` param description to encourage the LLM agent to use a number of tasks to break down the PRD into that is logical relative to project complexity.

.changeset/two-bats-smoke.md

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

.env.example

@@ -5,7 +5,7 @@ PERPLEXITY_API_KEY=your_perplexity_api_key_here     # Format: pplx-...
 # Model Configuration
 MODEL=claude-3-7-sonnet-20250219                    # Recommended models: claude-3-7-sonnet-20250219, claude-3-opus-20240229
 PERPLEXITY_MODEL=sonar-pro                          # Perplexity model for research-backed subtasks
-MAX_TOKENS=128000                                   # Maximum tokens for model responses
+MAX_TOKENS=64000                                    # Maximum tokens for model responses
 TEMPERATURE=0.2                                     # Temperature for model responses (0.0-1.0)
 
 # Logging Configuration

.prettierignore

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

CHANGELOG.md

@@ -1,5 +1,68 @@
 # task-master-ai
 
+## 0.11.0
+
+### Minor Changes
+
+- [#71](https://github.com/eyaltoledano/claude-task-master/pull/71) [`7141062`](https://github.com/eyaltoledano/claude-task-master/commit/71410629ba187776d92a31ea0729b2ff341b5e38) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - - **Easier Ways to Use Taskmaster (CLI & MCP):**
+  - You can now use Taskmaster either by installing it as a standard command-line tool (`task-master`) or as an MCP server directly within integrated development tools like Cursor (using its built-in features). **This makes Taskmaster accessible regardless of your preferred workflow.**
+  - Setting up a new project is simpler in integrated tools, thanks to the new `initialize_project` capability.
+  - **Complete MCP Implementation:**
+    - NOTE: Many MCP clients charge on a per tool basis. In that regard, the most cost-efficient way to use Taskmaster is through the CLI directly. Otherwise, the MCP offers the smoothest and most recommended user experience.
+    - All MCP tools now follow a standardized output format that mimicks RESTful API responses. They are lean JSON responses that are context-efficient. This is a net improvement over the last version which sent the whole CLI output directly, which needlessly wasted tokens.
+    - Added a `remove-task` command to permanently delete tasks you no longer need.
+    - Many new MCP tools are available for managing tasks (updating details, adding/removing subtasks, generating task files, setting status, finding the next task, breaking down complex tasks, handling dependencies, analyzing complexity, etc.), usable both from the command line and integrated tools. **(See the `taskmaster.mdc` reference guide and improved readme for a full list).**
+  - **Better Task Tracking:**
+    - Added a "cancelled" status option for tasks, providing more ways to categorize work.
+  - **Smoother Experience in Integrated Tools:**
+    - Long-running operations (like breaking down tasks or analysis) now run in the background **via an Async Operation Manager** with progress updates, so you know what's happening without waiting and can check status later.
+  - **Improved Documentation:**
+    - Added a comprehensive reference guide (`taskmaster.mdc`) detailing all commands and tools with examples, usage tips, and troubleshooting info. This is mostly for use by the AI but can be useful for human users as well.
+    - Updated the main README with clearer instructions and added a new tutorial/examples guide.
+    - Added documentation listing supported integrated tools (like Cursor).
+  - **Increased Stability & Reliability:**
+    - Using Taskmaster within integrated tools (like Cursor) is now **more stable and the recommended approach.**
+    - Added automated testing (CI) to catch issues earlier, leading to a more reliable tool.
+    - Fixed release process issues to ensure users get the correct package versions when installing or updating via npm.
+  - **Better Command-Line Experience:**
+    - Fixed bugs in the `expand-all` command that could cause **NaN errors or JSON formatting issues (especially when using `--research`).**
+    - Fixed issues with parameter validation in the `analyze-complexity` command (specifically related to the `threshold` parameter).
+    - Made the `add-task` command more consistent by adding standard flags like `--title`, `--description` for manual task creation so you don't have to use `--prompt` and can quickly drop new ideas and stay in your flow.
+    - Improved error messages for incorrect commands or flags, making them easier to understand.
+    - Added confirmation warnings before permanently deleting tasks (`remove-task`) to prevent mistakes. There's a known bug for deleting multiple tasks with comma-separated values. It'll be fixed next release.
+    - Renamed some background tool names used by integrated tools (e.g., `list-tasks` is now `get_tasks`) to be more intuitive if seen in logs or AI interactions.
+    - Smoother project start: **Improved the guidance provided to AI assistants immediately after setup** (related to `init` and `parse-prd` steps). This ensures the AI doesn't go on a tangent deciding its own workflow, and follows the exact process outlined in the Taskmaster workflow.
+  - **Clearer Error Messages:**
+    - When generating subtasks fails, error messages are now clearer, **including specific task IDs and potential suggestions.**
+    - AI fallback from Claude to Perplexity now also works the other way around. If Perplexity is down, will switch to Claude.
+  - **Simplified Setup & Configuration:**
+    - Made it clearer how to configure API keys depending on whether you're using the command-line tool (`.env` file) or an integrated tool (`.cursor/mcp.json` file).
+    - Taskmaster is now better at automatically finding your project files, especially in integrated tools, reducing the need for manual path settings.
+    - Fixed an issue that could prevent Taskmaster from working correctly immediately after initialization in integrated tools (related to how the MCP server was invoked). This should solve the issue most users were experiencing with the last release (0.10.x)
+    - Updated setup templates with clearer examples for API keys.
+    - \*\*For advanced users setting up the MCP server manually, the command is now `npx -y task-master-ai task-master-mcp`.
+  - **Enhanced Performance & AI:**
+    - Updated underlying AI model settings:
+      - **Increased Context Window:** Can now handle larger projects/tasks due to an increased Claude context window (64k -> 128k tokens).
+      - **Reduced AI randomness:** More consistent and predictable AI outputs (temperature 0.4 -> 0.2).
+      - **Updated default AI models:** Uses newer models like `claude-3-7-sonnet-20250219` and Perplexity `sonar-pro` by default.
+      - **More granular breakdown:** Increased the default number of subtasks generated by `expand` to 5 (from 4).
+      - **Consistent defaults:** Set the default priority for new tasks consistently to "medium".
+    - Improved performance when viewing task details in integrated tools by sending less redundant data.
+  - **Documentation Clarity:**
+    - Clarified in documentation that Markdown files (`.md`) can be used for Product Requirements Documents (`parse_prd`).
+    - Improved the description for the `numTasks` option in `parse_prd` for better guidance.
+  - **Improved Visuals (CLI):**
+    - Enhanced the look and feel of progress bars and status updates in the command line.
+    - Added a helpful color-coded progress bar to the task details view (`show` command) to visualize subtask completion.
+    - Made progress bars show a breakdown of task statuses (e.g., how many are pending vs. done).
+    - Made status counts clearer with text labels next to icons.
+    - Prevented progress bars from messing up the display on smaller terminal windows.
+    - Adjusted how progress is calculated for 'deferred' and 'cancelled' tasks in the progress bar, while still showing their distinct status visually.
+  - **Fixes for Integrated Tools:**
+    - Fixed how progress updates are sent to integrated tools, ensuring they display correctly.
+    - Fixed internal issues that could cause errors or invalid JSON responses when using Taskmaster with integrated tools.
+
 ## 0.10.1
 
 ### Patch Changes

README-task-master.md

@@ -146,7 +146,7 @@ To enable enhanced task management capabilities directly within Cursor using the
 4. Configure with the following details:
    - Name: "Task Master"
    - Type: "Command"
-   - Command: "npx -y --package task-master-ai task-master-mcp"
+   - Command: "npx -y task-master-ai"
 5. Save the settings
 
 Once configured, you can interact with Task Master's task management commands directly through Cursor's interface, providing a more integrated experience.

README.md

@@ -27,13 +27,13 @@ MCP (Model Control Protocol) provides the easiest way to get started with Task M
 	"mcpServers": {
 		"taskmaster-ai": {
 			"command": "npx",
-			"args": ["-y", "--package", "task-master-ai", "task-master-mcp"],
+			"args": ["-y", "task-master-ai"],
 			"env": {
 				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
 				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
 				"MODEL": "claude-3-7-sonnet-20250219",
 				"PERPLEXITY_MODEL": "sonar-pro",
-				"MAX_TOKENS": 128000,
+				"MAX_TOKENS": 64000,
 				"TEMPERATURE": 0.2,
 				"DEFAULT_SUBTASKS": 5,
 				"DEFAULT_PRIORITY": "medium"

bin/task-master.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node --trace-deprecation
+#!/usr/bin/env node
 
 /**
  * Task Master

docs/tutorial.md

@@ -17,13 +17,13 @@ MCP (Model Control Protocol) provides the easiest way to get started with Task M
 	"mcpServers": {
 		"taskmaster-ai": {
 			"command": "npx",
-			"args": ["-y", "--package", "task-master-ai", "task-master-mcp"],
+			"args": ["-y", "task-master-ai"],
 			"env": {
 				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
 				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
 				"MODEL": "claude-3-7-sonnet-20250219",
 				"PERPLEXITY_MODEL": "sonar-pro",
-				"MAX_TOKENS": 128000,
+				"MAX_TOKENS": 64000,
 				"TEMPERATURE": 0.2,
 				"DEFAULT_SUBTASKS": 5,
 				"DEFAULT_PRIORITY": "medium"
@@ -132,7 +132,7 @@ You can also set up the MCP server in Cursor settings:
 4. Configure with the following details:
    - Name: "Task Master"
    - Type: "Command"
-   - Command: "npx -y --package task-master-ai task-master-mcp"
+   - Command: "npx -y task-master-mcp"
 5. Save the settings
 
 Once configured, you can interact with Task Master's task management commands directly through Cursor's interface, providing a more integrated experience.

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

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

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

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

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

@@ -4,7 +4,6 @@
  */
 
 import { addTask } from '../../../../scripts/modules/task-manager.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -38,12 +37,27 @@ import {
  * @returns {Promise<Object>} - Result object { success: boolean, data?: any, error?: { code: string, message: string } }
  */
 export async function addTaskDirect(args, log, context = {}) {
+	// Destructure expected args
+	const { tasksJsonPath, prompt, dependencies, priority, research } = args;
 	try {
 		// Enable silent mode to prevent console logs from interfering with JSON response
 		enableSilentMode();
 
-		// Find the tasks.json path
-		const tasksPath = findTasksJsonPath(args, log);
+		// Check if tasksJsonPath was provided
+		if (!tasksJsonPath) {
+			log.error('addTaskDirect called without tasksJsonPath');
+			disableSilentMode(); // Disable before returning
+			return {
+				success: false,
+				error: {
+					code: 'MISSING_ARGUMENT',
+					message: 'tasksJsonPath is required'
+				}
+			};
+		}
+
+		// Use provided path
+		const tasksPath = tasksJsonPath;
 
 		// Check if this is manual task creation or AI-driven task creation
 		const isManualCreation = args.title && args.description;
@@ -65,15 +79,15 @@ export async function addTaskDirect(args, log, context = {}) {
 		}
 
 		// Extract and prepare parameters
-		const prompt = args.prompt;
-		const dependencies = Array.isArray(args.dependencies)
-			? args.dependencies
-			: args.dependencies
-				? String(args.dependencies)
+		const taskPrompt = prompt;
+		const taskDependencies = Array.isArray(dependencies)
+			? dependencies
+			: dependencies
+				? String(dependencies)
 						.split(',')
 						.map((id) => parseInt(id.trim(), 10))
 				: [];
-		const priority = args.priority || 'medium';
+		const taskPriority = priority || 'medium';
 
 		// Extract context parameters for advanced functionality
 		const { session } = context;
@@ -90,14 +104,14 @@ export async function addTaskDirect(args, log, context = {}) {
 			};
 
 			log.info(
-				`Adding new task manually with title: "${args.title}", dependencies: [${dependencies.join(', ')}], priority: ${priority}`
+				`Adding new task manually with title: "${args.title}", dependencies: [${taskDependencies.join(', ')}], priority: ${priority}`
 			);
 
 			// Call the addTask function with manual task data
 			const newTaskId = await addTask(
 				tasksPath,
 				null, // No prompt needed for manual creation
-				dependencies,
+				taskDependencies,
 				priority,
 				{
 					mcpLog: log,
@@ -121,7 +135,7 @@ export async function addTaskDirect(args, log, context = {}) {
 		} else {
 			// AI-driven task creation
 			log.info(
-				`Adding new task with prompt: "${prompt}", dependencies: [${dependencies.join(', ')}], priority: ${priority}`
+				`Adding new task with prompt: "${prompt}", dependencies: [${taskDependencies.join(', ')}], priority: ${priority}`
 			);
 
 			// Initialize AI client with session environment
@@ -207,7 +221,7 @@ export async function addTaskDirect(args, log, context = {}) {
 			const newTaskId = await addTask(
 				tasksPath,
 				prompt,
-				dependencies,
+				taskDependencies,
 				priority,
 				{
 					mcpLog: log,

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

@@ -3,7 +3,6 @@
  */
 
 import { analyzeTaskComplexity } from '../../../../scripts/modules/task-manager.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode,
@@ -16,45 +15,60 @@ import path from 'path';
 /**
  * Analyze task complexity and generate recommendations
  * @param {Object} args - Function arguments
- * @param {string} [args.file] - Path to the tasks file
- * @param {string} [args.output] - Output file path for the report
+ * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
+ * @param {string} args.outputPath - Explicit absolute path to save the report.
  * @param {string} [args.model] - LLM model to use for analysis
  * @param {string|number} [args.threshold] - Minimum complexity score to recommend expansion (1-10)
  * @param {boolean} [args.research] - Use Perplexity AI for research-backed complexity analysis
- * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @param {Object} [context={}] - Context object containing session data
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 	const { session } = context; // Only extract session, not reportProgress
+	// Destructure expected args
+	const { tasksJsonPath, outputPath, model, threshold, research } = args;
 
 	try {
 		log.info(`Analyzing task complexity with args: ${JSON.stringify(args)}`);
 
-		// Find the tasks.json path
-		const tasksPath = findTasksJsonPath(args, log);
-
-		// Determine output path
-		let outputPath = args.output || 'scripts/task-complexity-report.json';
-		if (!path.isAbsolute(outputPath) && args.projectRoot) {
-			outputPath = path.join(args.projectRoot, outputPath);
+		// Check if required paths were provided
+		if (!tasksJsonPath) {
+			log.error('analyzeTaskComplexityDirect called without tasksJsonPath');
+			return {
+				success: false,
+				error: {
+					code: 'MISSING_ARGUMENT',
+					message: 'tasksJsonPath is required'
+				}
+			};
+		}
+		if (!outputPath) {
+			log.error('analyzeTaskComplexityDirect called without outputPath');
+			return {
+				success: false,
+				error: { code: 'MISSING_ARGUMENT', message: 'outputPath is required' }
+			};
 		}
 
-		log.info(`Analyzing task complexity from: ${tasksPath}`);
-		log.info(`Output report will be saved to: ${outputPath}`);
+		// Use the provided paths
+		const tasksPath = tasksJsonPath;
+		const resolvedOutputPath = outputPath;
 
-		if (args.research) {
+		log.info(`Analyzing task complexity from: ${tasksPath}`);
+		log.info(`Output report will be saved to: ${resolvedOutputPath}`);
+
+		if (research) {
 			log.info('Using Perplexity AI for research-backed complexity analysis');
 		}
 
-		// Create options object for analyzeTaskComplexity
+		// Create options object for analyzeTaskComplexity using provided paths
 		const options = {
 			file: tasksPath,
-			output: outputPath,
-			model: args.model,
-			threshold: args.threshold,
-			research: args.research === true
+			output: resolvedOutputPath,
+			model: model,
+			threshold: threshold,
+			research: research === true
 		};
 
 		// Enable silent mode to prevent console logs from interfering with JSON response
@@ -95,7 +109,7 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 		}
 
 		// Verify the report file was created
-		if (!fs.existsSync(outputPath)) {
+		if (!fs.existsSync(resolvedOutputPath)) {
 			return {
 				success: false,
 				error: {
@@ -108,7 +122,7 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 		// Read the report file
 		let report;
 		try {
-			report = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+			report = JSON.parse(fs.readFileSync(resolvedOutputPath, 'utf8'));
 
 			// Important: Handle different report formats
 			// The core function might return an array or an object with a complexityAnalysis property
@@ -130,8 +144,8 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 			return {
 				success: true,
 				data: {
-					message: `Task complexity analysis complete. Report saved to ${outputPath}`,
-					reportPath: outputPath,
+					message: `Task complexity analysis complete. Report saved to ${resolvedOutputPath}`,
+					reportPath: resolvedOutputPath,
 					reportSummary: {
 						taskCount: analysisArray.length,
 						highComplexityTasks,

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

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

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

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

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

@@ -8,7 +8,6 @@ import {
 	disableSilentMode,
 	isSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import { getAnthropicClientForMCP } from '../utils/ai-client-utils.js';
 import path from 'path';
 import fs from 'fs';
@@ -16,34 +15,51 @@ import fs from 'fs';
 /**
  * Expand all pending tasks with subtasks
  * @param {Object} args - Function arguments
+ * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {number|string} [args.num] - Number of subtasks to generate
  * @param {boolean} [args.research] - Enable Perplexity AI for research-backed subtask generation
  * @param {string} [args.prompt] - Additional context to guide subtask generation
  * @param {boolean} [args.force] - Force regeneration of subtasks for tasks that already have them
- * @param {string} [args.file] - Path to the tasks file
- * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @param {Object} context - Context object containing session
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function expandAllTasksDirect(args, log, context = {}) {
 	const { session } = context; // Only extract session, not reportProgress
+	// Destructure expected args
+	const { tasksJsonPath, num, research, prompt, force } = args;
 
 	try {
 		log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
 
+		// Check if tasksJsonPath was provided
+		if (!tasksJsonPath) {
+			log.error('expandAllTasksDirect called without tasksJsonPath');
+			return {
+				success: false,
+				error: {
+					code: 'MISSING_ARGUMENT',
+					message: 'tasksJsonPath is required'
+				}
+			};
+		}
+
 		// Enable silent mode early to prevent any console output
 		enableSilentMode();
 
 		try {
-			// Find the tasks.json path
+			// Remove internal path finding
+			/*
 			const tasksPath = findTasksJsonPath(args, log);
+			*/
+			// Use provided path
+			const tasksPath = tasksJsonPath;
 
 			// Parse parameters
-			const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
-			const useResearch = args.research === true;
-			const additionalContext = args.prompt || '';
-			const forceFlag = args.force === true;
+			const numSubtasks = num ? parseInt(num, 10) : undefined;
+			const useResearch = research === true;
+			const additionalContext = prompt || '';
+			const forceFlag = force === true;
 
 			log.info(
 				`Expanding all tasks with ${numSubtasks || 'default'} subtasks each...`

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

@@ -11,7 +11,6 @@ import {
 	disableSilentMode,
 	isSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	getAnthropicClientForMCP,
 	getModelConfig
@@ -23,12 +22,20 @@ import fs from 'fs';
  * Direct function wrapper for expanding a task into subtasks with error handling.
  *
  * @param {Object} args - Command arguments
+ * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
+ * @param {string} args.id - The ID of the task to expand.
+ * @param {number|string} [args.num] - Number of subtasks to generate.
+ * @param {boolean} [args.research] - Enable Perplexity AI for research-backed subtask generation.
+ * @param {string} [args.prompt] - Additional context to guide subtask generation.
+ * @param {boolean} [args.force] - Force expansion even if subtasks exist.
  * @param {Object} log - Logger object
  * @param {Object} context - Context object containing session and reportProgress
  * @returns {Promise<Object>} - Task expansion result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
 export async function expandTaskDirect(args, log, context = {}) {
 	const { session } = context;
+	// Destructure expected args
+	const { tasksJsonPath, id, num, research, prompt, force } = args;
 
 	// Log session root data for debugging
 	log.info(
@@ -40,48 +47,26 @@ export async function expandTaskDirect(args, log, context = {}) {
 		})}`
 	);
 
-	let tasksPath;
-	try {
-		// If a direct file path is provided, use it directly
-		if (args.file && fs.existsSync(args.file)) {
-			log.info(
-				`[expandTaskDirect] Using explicitly provided tasks file: ${args.file}`
-			);
-			tasksPath = args.file;
-		} else {
-			// Find the tasks path through standard logic
-			log.info(
-				`[expandTaskDirect] No direct file path provided or file not found at ${args.file}, searching using findTasksJsonPath`
-			);
-			tasksPath = findTasksJsonPath(args, log);
-		}
-	} catch (error) {
-		log.error(
-			`[expandTaskDirect] Error during tasksPath determination: ${error.message}`
-		);
-
-		// Include session roots information in error
-		const sessionRootsInfo = session
-			? `\nSession.roots: ${JSON.stringify(session.roots)}\n` +
-				`Current Working Directory: ${process.cwd()}\n` +
-				`Args.projectRoot: ${args.projectRoot}\n` +
-				`Args.file: ${args.file}\n`
-			: '\nSession object not available';
-
+	// Check if tasksJsonPath was provided
+	if (!tasksJsonPath) {
+		log.error('expandTaskDirect called without tasksJsonPath');
 		return {
 			success: false,
 			error: {
-				code: 'FILE_NOT_FOUND_ERROR',
-				message: `Error determining tasksPath: ${error.message}${sessionRootsInfo}`
+				code: 'MISSING_ARGUMENT',
+				message: 'tasksJsonPath is required'
 			},
 			fromCache: false
 		};
 	}
 
-	log.info(`[expandTaskDirect] Determined tasksPath: ${tasksPath}`);
+	// Use provided path
+	const tasksPath = tasksJsonPath;
+
+	log.info(`[expandTaskDirect] Using tasksPath: ${tasksPath}`);
 
 	// Validate task ID
-	const taskId = args.id ? parseInt(args.id, 10) : null;
+	const taskId = id ? parseInt(id, 10) : null;
 	if (!taskId) {
 		log.error('Task ID is required');
 		return {
@@ -95,9 +80,10 @@ export async function expandTaskDirect(args, log, context = {}) {
 	}
 
 	// Process other parameters
-	const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
-	const useResearch = args.research === true;
-	const additionalContext = args.prompt || '';
+	const numSubtasks = num ? parseInt(num, 10) : undefined;
+	const useResearch = research === true;
+	const additionalContext = prompt || '';
+	const forceFlag = force === true;
 
 	// Initialize AI client if needed (for expandTask function)
 	try {
@@ -172,15 +158,16 @@ export async function expandTaskDirect(args, log, context = {}) {
 			};
 		}
 
-		// Check for existing subtasks
+		// Check for existing subtasks and force flag
 		const hasExistingSubtasks = task.subtasks && task.subtasks.length > 0;
-
-		// If the task already has subtasks, just return it (matching core behavior)
-		if (hasExistingSubtasks) {
-			log.info(`Task ${taskId} already has ${task.subtasks.length} subtasks`);
+		if (hasExistingSubtasks && !forceFlag) {
+			log.info(
+				`Task ${taskId} already has ${task.subtasks.length} subtasks. Use --force to overwrite.`
+			);
 			return {
 				success: true,
 				data: {
+					message: `Task ${taskId} already has subtasks. Expansion skipped.`,
 					task,
 					subtasksAdded: 0,
 					hasExistingSubtasks
@@ -189,6 +176,14 @@ export async function expandTaskDirect(args, log, context = {}) {
 			};
 		}
 
+		// If force flag is set, clear existing subtasks
+		if (hasExistingSubtasks && forceFlag) {
+			log.info(
+				`Force flag set. Clearing existing subtasks for task ${taskId}.`
+			);
+			task.subtasks = [];
+		}
+
 		// Keep a copy of the task before modification
 		const originalTask = JSON.parse(JSON.stringify(task));
 

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

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

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

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

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

@@ -1,5 +1,4 @@
-import path from 'path';
-import { initializeProject, log as initLog } from '../../../../scripts/init.js'; // Import core function and its logger if needed separately
+import { initializeProject } from '../../../../scripts/init.js'; // Import core function and its logger if needed separately
 import {
 	enableSilentMode,
 	disableSilentMode

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

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

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

@@ -6,7 +6,6 @@
 import { findNextTask } from '../../../../scripts/modules/task-manager.js';
 import { readJSON } from '../../../../scripts/modules/utils.js';
 import { getCachedOrExecute } from '../../tools/utils.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -16,28 +15,28 @@ import {
  * Direct function wrapper for finding the next task to work on with error handling and caching.
  *
  * @param {Object} args - Command arguments
+ * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Next task result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
 export async function nextTaskDirect(args, log) {
-	let tasksPath;
-	try {
-		// Find the tasks path first - needed for cache key and execution
-		tasksPath = findTasksJsonPath(args, log);
-	} catch (error) {
-		log.error(`Tasks file not found: ${error.message}`);
+	// Destructure expected args
+	const { tasksJsonPath } = args;
+
+	if (!tasksJsonPath) {
+		log.error('nextTaskDirect called without tasksJsonPath');
 		return {
 			success: false,
 			error: {
-				code: 'FILE_NOT_FOUND_ERROR',
-				message: error.message
+				code: 'MISSING_ARGUMENT',
+				message: 'tasksJsonPath is required'
 			},
 			fromCache: false
 		};
 	}
 
-	// Generate cache key using task path
-	const cacheKey = `nextTask:${tasksPath}`;
+	// Generate cache key using the provided task path
+	const cacheKey = `nextTask:${tasksJsonPath}`;
 
 	// Define the action function to be executed on cache miss
 	const coreNextTaskAction = async () => {
@@ -45,16 +44,17 @@ export async function nextTaskDirect(args, log) {
 			// Enable silent mode to prevent console logs from interfering with JSON response
 			enableSilentMode();
 
-			log.info(`Finding next task from ${tasksPath}`);
+			log.info(`Finding next task from ${tasksJsonPath}`);
 
-			// Read tasks data
-			const data = readJSON(tasksPath);
+			// Read tasks data using the provided path
+			const data = readJSON(tasksJsonPath);
 			if (!data || !data.tasks) {
+				disableSilentMode(); // Disable before return
 				return {
 					success: false,
 					error: {
 						code: 'INVALID_TASKS_FILE',
-						message: `No valid tasks found in ${tasksPath}`
+						message: `No valid tasks found in ${tasksJsonPath}`
 					}
 				};
 			}

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

@@ -47,21 +47,9 @@ export async function parsePRDDirect(args, log, context = {}) {
 			};
 		}
 
-		// --- Parameter validation and path resolution ---
-		if (!args.input) {
-			const errorMessage =
-				'No input file specified. Please provide an input PRD document path.';
-			log.error(errorMessage);
-			return {
-				success: false,
-				error: { code: 'MISSING_INPUT_FILE', message: errorMessage },
-				fromCache: false
-			};
-		}
-
-		// Validate projectRoot
+		// Validate required parameters
 		if (!args.projectRoot) {
-			const errorMessage = 'Project root is required but was not provided';
+			const errorMessage = 'Project root is required for parsePRDDirect';
 			log.error(errorMessage);
 			return {
 				success: false,
@@ -70,53 +58,32 @@ export async function parsePRDDirect(args, log, context = {}) {
 			};
 		}
 
-		const homeDir = os.homedir();
-		// Disallow invalid projectRoot values
-		if (args.projectRoot === '/' || args.projectRoot === homeDir) {
-			const errorMessage = `Invalid project root: ${args.projectRoot}. Cannot use root or home directory.`;
+		if (!args.input) {
+			const errorMessage = 'Input file path is required for parsePRDDirect';
 			log.error(errorMessage);
 			return {
 				success: false,
-				error: { code: 'INVALID_PROJECT_ROOT', message: errorMessage },
+				error: { code: 'MISSING_INPUT_PATH', message: errorMessage },
 				fromCache: false
 			};
 		}
 
-		// Resolve input path (relative to validated project root)
+		if (!args.output) {
+			const errorMessage = 'Output file path is required for parsePRDDirect';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_OUTPUT_PATH', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Resolve input path (expecting absolute path or path relative to project root)
 		const projectRoot = args.projectRoot;
-		log.info(`Using validated project root: ${projectRoot}`);
-
-		// Make sure the project root directory exists
-		if (!fs.existsSync(projectRoot)) {
-			const errorMessage = `Project root directory does not exist: ${projectRoot}`;
-			log.error(errorMessage);
-			return {
-				success: false,
-				error: { code: 'PROJECT_ROOT_NOT_FOUND', message: errorMessage },
-				fromCache: false
-			};
-		}
-
-		// Resolve input path relative to validated project root
 		const inputPath = path.isAbsolute(args.input)
 			? args.input
 			: path.resolve(projectRoot, args.input);
 
-		log.info(`Resolved input path: ${inputPath}`);
-
-		// Determine output path
-		let outputPath;
-		if (args.output) {
-			outputPath = path.isAbsolute(args.output)
-				? args.output
-				: path.resolve(projectRoot, args.output);
-		} else {
-			// Default to tasks/tasks.json in the project root
-			outputPath = path.resolve(projectRoot, 'tasks', 'tasks.json');
-		}
-
-		log.info(`Resolved output path: ${outputPath}`);
-
 		// Verify input file exists
 		if (!fs.existsSync(inputPath)) {
 			const errorMessage = `Input file not found: ${inputPath}`;
@@ -132,6 +99,18 @@ export async function parsePRDDirect(args, log, context = {}) {
 			};
 		}
 
+		// Resolve output path (expecting absolute path or path relative to project root)
+		const outputPath = path.isAbsolute(args.output)
+			? args.output
+			: path.resolve(projectRoot, args.output);
+
+		// Ensure output directory exists
+		const outputDir = path.dirname(outputPath);
+		if (!fs.existsSync(outputDir)) {
+			log.info(`Creating output directory: ${outputDir}`);
+			fs.mkdirSync(outputDir, { recursive: true });
+		}
+
 		// Parse number of tasks - handle both string and number values
 		let numTasks = 10; // Default
 		if (args.numTasks) {

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

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

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

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

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

@@ -8,35 +8,35 @@ import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 
 /**
  * Direct function wrapper for removeTask with error handling.
  *
  * @param {Object} args - Command arguments
+ * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
+ * @param {string} args.id - The ID of the task or subtask to remove.
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Remove task result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: false }
  */
 export async function removeTaskDirect(args, log) {
+	// Destructure expected args
+	const { tasksJsonPath, id } = args;
 	try {
-		// Find the tasks path first
-		let tasksPath;
-		try {
-			tasksPath = findTasksJsonPath(args, log);
-		} catch (error) {
-			log.error(`Tasks file not found: ${error.message}`);
+		// Check if tasksJsonPath was provided
+		if (!tasksJsonPath) {
+			log.error('removeTaskDirect called without tasksJsonPath');
 			return {
 				success: false,
 				error: {
-					code: 'FILE_NOT_FOUND_ERROR',
-					message: error.message
+					code: 'MISSING_ARGUMENT',
+					message: 'tasksJsonPath is required'
 				},
 				fromCache: false
 			};
 		}
 
 		// Validate task ID parameter
-		const taskId = args.id;
+		const taskId = id;
 		if (!taskId) {
 			log.error('Task ID is required');
 			return {
@@ -50,14 +50,14 @@ export async function removeTaskDirect(args, log) {
 		}
 
 		// Skip confirmation in the direct function since it's handled by the client
-		log.info(`Removing task with ID: ${taskId} from ${tasksPath}`);
+		log.info(`Removing task with ID: ${taskId} from ${tasksJsonPath}`);
 
 		try {
 			// Enable silent mode to prevent console logs from interfering with JSON response
 			enableSilentMode();
 
-			// Call the core removeTask function
-			const result = await removeTask(tasksPath, taskId);
+			// Call the core removeTask function using the provided path
+			const result = await removeTask(tasksJsonPath, taskId);
 
 			// Restore normal logging
 			disableSilentMode();
@@ -70,7 +70,7 @@ export async function removeTaskDirect(args, log) {
 				data: {
 					message: result.message,
 					taskId: taskId,
-					tasksPath: tasksPath,
+					tasksPath: tasksJsonPath,
 					removedTask: result.removedTask
 				},
 				fromCache: false

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

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

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

@@ -6,7 +6,6 @@
 import { findTaskById } from '../../../../scripts/modules/utils.js';
 import { readJSON } from '../../../../scripts/modules/utils.js';
 import { getCachedOrExecute } from '../../tools/utils.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -16,28 +15,29 @@ import {
  * Direct function wrapper for showing task details with error handling and caching.
  *
  * @param {Object} args - Command arguments
+ * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
+ * @param {string} args.id - The ID of the task or subtask to show.
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Task details result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
 export async function showTaskDirect(args, log) {
-	let tasksPath;
-	try {
-		// Find the tasks path first - needed for cache key and execution
-		tasksPath = findTasksJsonPath(args, log);
-	} catch (error) {
-		log.error(`Tasks file not found: ${error.message}`);
+	// Destructure expected args
+	const { tasksJsonPath, id } = args;
+
+	if (!tasksJsonPath) {
+		log.error('showTaskDirect called without tasksJsonPath');
 		return {
 			success: false,
 			error: {
-				code: 'FILE_NOT_FOUND_ERROR',
-				message: error.message
+				code: 'MISSING_ARGUMENT',
+				message: 'tasksJsonPath is required'
 			},
 			fromCache: false
 		};
 	}
 
 	// Validate task ID
-	const taskId = args.id;
+	const taskId = id;
 	if (!taskId) {
 		log.error('Task ID is required');
 		return {
@@ -50,8 +50,8 @@ export async function showTaskDirect(args, log) {
 		};
 	}
 
-	// Generate cache key using task path and ID
-	const cacheKey = `showTask:${tasksPath}:${taskId}`;
+	// Generate cache key using the provided task path and ID
+	const cacheKey = `showTask:${tasksJsonPath}:${taskId}`;
 
 	// Define the action function to be executed on cache miss
 	const coreShowTaskAction = async () => {
@@ -59,16 +59,19 @@ export async function showTaskDirect(args, log) {
 			// Enable silent mode to prevent console logs from interfering with JSON response
 			enableSilentMode();
 
-			log.info(`Retrieving task details for ID: ${taskId} from ${tasksPath}`);
+			log.info(
+				`Retrieving task details for ID: ${taskId} from ${tasksJsonPath}`
+			);
 
-			// Read tasks data
-			const data = readJSON(tasksPath);
+			// 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 ${tasksPath}`
+						message: `No valid tasks found in ${tasksJsonPath}`
 					}
 				};
 			}
@@ -77,6 +80,7 @@ export async function showTaskDirect(args, log) {
 			const task = findTaskById(data.tasks, taskId);
 
 			if (!task) {
+				disableSilentMode(); // Disable before returning
 				return {
 					success: false,
 					error: {

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

@@ -8,7 +8,6 @@ import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	getAnthropicClientForMCP,
 	getPerplexityClientForMCP
@@ -17,19 +16,31 @@ import {
 /**
  * Direct function wrapper for updateSubtaskById with error handling.
  *
- * @param {Object} args - Command arguments containing id, prompt, useResearch and file path options.
+ * @param {Object} args - Command arguments containing id, prompt, useResearch and tasksJsonPath.
  * @param {Object} log - Logger object.
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function updateSubtaskByIdDirect(args, log, context = {}) {
 	const { session } = context; // Only extract session, not reportProgress
+	const { tasksJsonPath, id, prompt, research } = args;
 
 	try {
 		log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
 
-		// Check required parameters
-		if (!args.id) {
+		// Check if tasksJsonPath was provided
+		if (!tasksJsonPath) {
+			const errorMessage = 'tasksJsonPath is required but was not provided.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Check required parameters (id and prompt)
+		if (!id) {
 			const errorMessage =
 				'No subtask ID specified. Please provide a subtask ID to update.';
 			log.error(errorMessage);
@@ -40,7 +51,7 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 			};
 		}
 
-		if (!args.prompt) {
+		if (!prompt) {
 			const errorMessage =
 				'No prompt specified. Please provide a prompt with information to add to the subtask.';
 			log.error(errorMessage);
@@ -52,7 +63,7 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 		}
 
 		// Validate subtask ID format
-		const subtaskId = args.id;
+		const subtaskId = id;
 		if (typeof subtaskId !== 'string' && typeof subtaskId !== 'number') {
 			const errorMessage = `Invalid subtask ID type: ${typeof subtaskId}. Subtask ID must be a string or number.`;
 			log.error(errorMessage);
@@ -74,24 +85,14 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 			};
 		}
 
-		// Get tasks file path
-		let tasksPath;
-		try {
-			tasksPath = findTasksJsonPath(args, log);
-		} catch (error) {
-			log.error(`Error finding tasks file: ${error.message}`);
-			return {
-				success: false,
-				error: { code: 'TASKS_FILE_ERROR', message: error.message },
-				fromCache: false
-			};
-		}
+		// Use the provided path
+		const tasksPath = tasksJsonPath;
 
 		// Get research flag
-		const useResearch = args.research === true;
+		const useResearch = research === true;
 
 		log.info(
-			`Updating subtask with ID ${subtaskIdStr} with prompt "${args.prompt}" and research: ${useResearch}`
+			`Updating subtask with ID ${subtaskIdStr} with prompt "${prompt}" and research: ${useResearch}`
 		);
 
 		// Initialize the appropriate AI client based on research flag
@@ -134,7 +135,7 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 			const updatedSubtask = await updateSubtaskById(
 				tasksPath,
 				subtaskIdStr,
-				args.prompt,
+				prompt,
 				useResearch,
 				{
 					session,

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

@@ -4,7 +4,6 @@
  */
 
 import { updateTaskById } from '../../../../scripts/modules/task-manager.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -17,19 +16,32 @@ import {
 /**
  * Direct function wrapper for updateTaskById with error handling.
  *
- * @param {Object} args - Command arguments containing id, prompt, useResearch and file path options.
+ * @param {Object} args - Command arguments containing id, prompt, useResearch and tasksJsonPath.
  * @param {Object} log - Logger object.
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function updateTaskByIdDirect(args, log, context = {}) {
 	const { session } = context; // Only extract session, not reportProgress
+	// Destructure expected args, including the resolved tasksJsonPath
+	const { tasksJsonPath, id, prompt, research } = args;
 
 	try {
 		log.info(`Updating task with args: ${JSON.stringify(args)}`);
 
-		// Check required parameters
-		if (!args.id) {
+		// Check if tasksJsonPath was provided
+		if (!tasksJsonPath) {
+			const errorMessage = 'tasksJsonPath is required but was not provided.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Check required parameters (id and prompt)
+		if (!id) {
 			const errorMessage =
 				'No task ID specified. Please provide a task ID to update.';
 			log.error(errorMessage);
@@ -40,7 +52,7 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 			};
 		}
 
-		if (!args.prompt) {
+		if (!prompt) {
 			const errorMessage =
 				'No prompt specified. Please provide a prompt with new information for the task update.';
 			log.error(errorMessage);
@@ -53,15 +65,15 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 
 		// Parse taskId - handle both string and number values
 		let taskId;
-		if (typeof args.id === 'string') {
+		if (typeof id === 'string') {
 			// Handle subtask IDs (e.g., "5.2")
-			if (args.id.includes('.')) {
-				taskId = args.id; // Keep as string for subtask IDs
+			if (id.includes('.')) {
+				taskId = id; // Keep as string for subtask IDs
 			} else {
 				// Parse as integer for main task IDs
-				taskId = parseInt(args.id, 10);
+				taskId = parseInt(id, 10);
 				if (isNaN(taskId)) {
-					const errorMessage = `Invalid task ID: ${args.id}. Task ID must be a positive integer or subtask ID (e.g., "5.2").`;
+					const errorMessage = `Invalid task ID: ${id}. Task ID must be a positive integer or subtask ID (e.g., "5.2").`;
 					log.error(errorMessage);
 					return {
 						success: false,
@@ -71,24 +83,14 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 				}
 			}
 		} else {
-			taskId = args.id;
+			taskId = id;
 		}
 
-		// Get tasks file path
-		let tasksPath;
-		try {
-			tasksPath = findTasksJsonPath(args, log);
-		} catch (error) {
-			log.error(`Error finding tasks file: ${error.message}`);
-			return {
-				success: false,
-				error: { code: 'TASKS_FILE_ERROR', message: error.message },
-				fromCache: false
-			};
-		}
+		// Use the provided path
+		const tasksPath = tasksJsonPath;
 
 		// Get research flag
-		const useResearch = args.research === true;
+		const useResearch = research === true;
 
 		// Initialize appropriate AI client based on research flag
 		let aiClient;
@@ -113,7 +115,7 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 		}
 
 		log.info(
-			`Updating task with ID ${taskId} with prompt "${args.prompt}" and research: ${useResearch}`
+			`Updating task with ID ${taskId} with prompt "${prompt}" and research: ${useResearch}`
 		);
 
 		try {
@@ -133,7 +135,7 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 			await updateTaskById(
 				tasksPath,
 				taskId,
-				args.prompt,
+				prompt,
 				useResearch,
 				{
 					mcpLog: logWrapper, // Use our wrapper object that has the expected method structure
@@ -149,7 +151,7 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 				data: {
 					message: `Successfully updated task with ID ${taskId} based on the prompt`,
 					taskId,
-					tasksPath,
+					tasksPath: tasksPath, // Return the used path
 					useResearch
 				},
 				fromCache: false // This operation always modifies state and should never be cached

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

@@ -8,7 +8,6 @@ import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	getAnthropicClientForMCP,
 	getPerplexityClientForMCP
@@ -17,19 +16,31 @@ import {
 /**
  * Direct function wrapper for updating tasks based on new context/prompt.
  *
- * @param {Object} args - Command arguments containing fromId, prompt, useResearch and file path options.
+ * @param {Object} args - Command arguments containing fromId, prompt, useResearch and tasksJsonPath.
  * @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; // Only extract session, not reportProgress
+	const { tasksJsonPath, from, prompt, research } = args;
 
 	try {
 		log.info(`Updating tasks with args: ${JSON.stringify(args)}`);
 
+		// Check if tasksJsonPath was provided
+		if (!tasksJsonPath) {
+			const errorMessage = 'tasksJsonPath is required but was not provided.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
+				fromCache: false
+			};
+		}
+
 		// Check for the common mistake of using 'id' instead of 'from'
-		if (args.id !== undefined && args.from === undefined) {
+		if (args.id !== undefined && from === undefined) {
 			const errorMessage =
 				"You specified 'id' parameter but 'update' requires 'from' parameter. Use 'from' for this tool or use 'update_task' tool if you want to update a single task.";
 			log.error(errorMessage);
@@ -46,7 +57,7 @@ export async function updateTasksDirect(args, log, context = {}) {
 		}
 
 		// Check required parameters
-		if (!args.from) {
+		if (!from) {
 			const errorMessage =
 				'No from ID specified. Please provide a task ID to start updating from.';
 			log.error(errorMessage);
@@ -57,7 +68,7 @@ export async function updateTasksDirect(args, log, context = {}) {
 			};
 		}
 
-		if (!args.prompt) {
+		if (!prompt) {
 			const errorMessage =
 				'No prompt specified. Please provide a prompt with new context for task updates.';
 			log.error(errorMessage);
@@ -70,10 +81,10 @@ export async function updateTasksDirect(args, log, context = {}) {
 
 		// Parse fromId - handle both string and number values
 		let fromId;
-		if (typeof args.from === 'string') {
-			fromId = parseInt(args.from, 10);
+		if (typeof from === 'string') {
+			fromId = parseInt(from, 10);
 			if (isNaN(fromId)) {
-				const errorMessage = `Invalid from ID: ${args.from}. Task ID must be a positive integer.`;
+				const errorMessage = `Invalid from ID: ${from}. Task ID must be a positive integer.`;
 				log.error(errorMessage);
 				return {
 					success: false,
@@ -82,24 +93,11 @@ export async function updateTasksDirect(args, log, context = {}) {
 				};
 			}
 		} else {
-			fromId = args.from;
-		}
-
-		// Get tasks file path
-		let tasksPath;
-		try {
-			tasksPath = findTasksJsonPath(args, log);
-		} catch (error) {
-			log.error(`Error finding tasks file: ${error.message}`);
-			return {
-				success: false,
-				error: { code: 'TASKS_FILE_ERROR', message: error.message },
-				fromCache: false
-			};
+			fromId = from;
 		}
 
 		// Get research flag
-		const useResearch = args.research === true;
+		const useResearch = research === true;
 
 		// Initialize appropriate AI client based on research flag
 		let aiClient;
@@ -124,16 +122,25 @@ export async function updateTasksDirect(args, log, context = {}) {
 		}
 
 		log.info(
-			`Updating tasks from ID ${fromId} with prompt "${args.prompt}" and research: ${useResearch}`
+			`Updating tasks from ID ${fromId} with prompt "${prompt}" and research: ${useResearch}`
 		);
 
+		// Create the logger wrapper to ensure compatibility with core functions
+		const logWrapper = {
+			info: (message, ...args) => log.info(message, ...args),
+			warn: (message, ...args) => log.warn(message, ...args),
+			error: (message, ...args) => log.error(message, ...args),
+			debug: (message, ...args) => log.debug && log.debug(message, ...args), // Handle optional debug
+			success: (message, ...args) => log.info(message, ...args) // Map success to info if needed
+		};
+
 		try {
 			// Enable silent mode to prevent console logs from interfering with JSON response
 			enableSilentMode();
 
 			// Execute core updateTasks function, passing the AI client and session
-			await updateTasks(tasksPath, fromId, args.prompt, useResearch, {
-				mcpLog: log,
+			await updateTasks(tasksJsonPath, fromId, prompt, useResearch, {
+				mcpLog: logWrapper, // Pass the wrapper instead of the raw log object
 				session
 			});
 
@@ -144,7 +151,7 @@ export async function updateTasksDirect(args, log, context = {}) {
 				data: {
 					message: `Successfully updated tasks from ID ${fromId} based on the prompt`,
 					fromId,
-					tasksPath,
+					tasksPath: tasksJsonPath,
 					useResearch
 				},
 				fromCache: false // This operation always modifies state and should never be cached

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

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

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

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

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

@@ -1 +0,0 @@
- 

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

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

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

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

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

@@ -12,6 +12,7 @@ import {
 	handleApiResult
 } from './utils.js';
 import { addTaskDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the addTask tool with the MCP server
@@ -58,35 +59,54 @@ export function registerAddTaskTool(server) {
 				.describe('Path to the tasks file (default: tasks/tasks.json)'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				),
+				.describe('The directory of the project. Must be an absolute path.'),
 			research: z
 				.boolean()
 				.optional()
 				.describe('Whether to use research capabilities for task creation')
 		}),
-		execute: async (args, { log, reportProgress, session }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Starting add-task with args: ${JSON.stringify(args)}`);
 
-				// Get project root from session
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				// Call the direct function
 				const result = await addTaskDirect(
 					{
-						...args,
-						projectRoot: rootFolder
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						prompt: args.prompt,
+						dependencies: args.dependencies,
+						priority: args.priority,
+						research: args.research
 					},
 					log,
-					{ reportProgress, session }
+					{ session }
 				);
 
 				// Return the result

mcp-server/src/tools/analyze.js

@@ -10,6 +10,8 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { analyzeTaskComplexityDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
+import path from 'path';
 
 /**
  * Register the analyze tool with the MCP server
@@ -53,10 +55,7 @@ export function registerAnalyzeTool(server) {
 				.describe('Use Perplexity AI for research-backed complexity analysis'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
@@ -64,17 +63,40 @@ export function registerAnalyzeTool(server) {
 					`Analyzing task complexity with args: ${JSON.stringify(args)}`
 				);
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
+				}
+
+				const outputPath = args.output
+					? path.resolve(rootFolder, args.output)
+					: path.resolve(rootFolder, 'scripts', 'task-complexity-report.json');
+
 				const result = await analyzeTaskComplexityDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						tasksJsonPath: tasksJsonPath,
+						outputPath: outputPath,
+						model: args.model,
+						threshold: args.threshold,
+						research: args.research
 					},
 					log,
 					{ session }

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { clearSubtasksDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the clearSubtasks tool with the MCP server
@@ -34,38 +35,53 @@ export function registerClearSubtasksTool(server) {
 					),
 				projectRoot: z
 					.string()
-					.optional()
-					.describe(
-						'Root directory of the project (default: current working directory)'
-					)
+					.describe('The directory of the project. Must be an absolute path.')
 			})
 			.refine((data) => data.id || data.all, {
 				message: "Either 'id' or 'all' parameter must be provided",
 				path: ['id', 'all']
 			}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
-				await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await clearSubtasksDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						all: args.all
 					},
-					log,
-					{ reportProgress, mcpLog: log, session }
+					log
+					// Remove context object as clearSubtasksDirect likely doesn't need session/reportProgress
 				);
 
-				reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(`Subtasks cleared successfully: ${result.data.message}`);
 				} else {

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { complexityReportDirect } from '../core/task-master-core.js';
+import path from 'path';
 
 /**
  * Register the complexityReport tool with the MCP server
@@ -28,35 +29,40 @@ export function registerComplexityReportTool(server) {
 				),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(
 					`Getting complexity report with args: ${JSON.stringify(args)}`
 				);
-				// await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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(rootFolder, 'scripts', 'task-complexity-report.json');
+
 				const result = await complexityReportDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						reportPath: reportPath
+						// No other args specific to this tool
 					},
-					log /*, { reportProgress, mcpLog: log, session}*/
+					log
 				);
 
-				// await reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(
 						`Successfully retrieved complexity report${result.fromCache ? ' (from cache)' : ''}`

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { expandAllTasksDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the expandAll tool with the MCP server
@@ -48,26 +49,46 @@ export function registerExpandAllTool(server) {
 				),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await expandAllTasksDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						num: args.num,
+						research: args.research,
+						prompt: args.prompt,
+						force: args.force
 					},
 					log,
 					{ session }

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { expandTaskDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -23,10 +24,7 @@ export function registerExpandTaskTool(server) {
 		description: 'Expand a task into subtasks for detailed implementation',
 		parameters: z.object({
 			id: z.string().describe('ID of task to expand'),
-			num: z
-				.union([z.string(), z.number()])
-				.optional()
-				.describe('Number of subtasks to generate'),
+			num: z.string().optional().describe('Number of subtasks to generate'),
 			research: z
 				.boolean()
 				.optional()
@@ -38,42 +36,52 @@ export function registerExpandTaskTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.'),
+			force: z.boolean().optional().describe('Force the expansion')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Starting expand-task with args: ${JSON.stringify(args)}`);
 
-				// Get project root from session
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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(`Project root resolved to: ${rootFolder}`);
 
-				// Check for tasks.json in the standard locations
-				const tasksJsonPath = path.join(rootFolder, 'tasks', 'tasks.json');
-
-				if (fs.existsSync(tasksJsonPath)) {
-					log.info(`Found tasks.json at ${tasksJsonPath}`);
-					// Add the file parameter directly to args
-					args.file = tasksJsonPath;
-				} else {
-					log.warn(`Could not find tasks.json at ${tasksJsonPath}`);
+				// Resolve the path to tasks.json using the utility
+				let tasksJsonPath;
+				try {
+					tasksJsonPath = findTasksJsonPath(
+						{ projectRoot: rootFolder, file: args.file },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				// Call direct function with only session in the context, not reportProgress
 				// Use the pattern recommended in the MCP guidelines
 				const result = await expandTaskDirect(
 					{
-						...args,
-						projectRoot: rootFolder
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						num: args.num,
+						research: args.research,
+						prompt: args.prompt,
+						force: args.force // Need to add force to parameters
 					},
 					log,
 					{ session }

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { fixDependenciesDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the fixDependencies tool with the MCP server
@@ -23,34 +24,42 @@ export function registerFixDependenciesTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Fixing dependencies with args: ${JSON.stringify(args)}`);
-				await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await fixDependenciesDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						tasksJsonPath: tasksJsonPath
 					},
-					log,
-					{ reportProgress, mcpLog: log, session }
+					log
 				);
 
-				await reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(`Successfully fixed dependencies: ${result.data.message}`);
 				} else {

mcp-server/src/tools/generate.js

@@ -10,6 +10,8 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { generateTaskFilesDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
+import path from 'path';
 
 /**
  * Register the generate tool with the MCP server
@@ -28,33 +30,52 @@ export function registerGenerateTool(server) {
 				.describe('Output directory (default: same directory as tasks file)'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Generating task files with args: ${JSON.stringify(args)}`);
-				// await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
+				}
+
+				// 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.dirname(tasksJsonPath);
+
 				const result = await generateTaskFilesDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved paths
+						tasksJsonPath: tasksJsonPath,
+						outputDir: outputDir
+						// No other args specific to this tool
 					},
-					log /*, { reportProgress, mcpLog: log, session}*/
+					log
 				);
 
-				// await reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(`Successfully generated task files: ${result.data.message}`);
 				} else {

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { showTaskDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Custom processor function that removes allTasks from the response
@@ -42,12 +43,9 @@ export function registerShowTaskTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			// Log the session right at the start of execute
 			log.info(
 				`Session object received in execute: ${JSON.stringify(session)}`
@@ -60,26 +58,43 @@ export function registerShowTaskTool(server) {
 					`Session object received in execute: ${JSON.stringify(session)}`
 				); // Use JSON.stringify for better visibility
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
-				} else if (!rootFolder) {
-					// Ensure we always have *some* root, even if session failed and args didn't provide one
-					rootFolder = process.cwd();
-					log.warn(
-						`Session and args failed to provide root, using CWD: ${rootFolder}`
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
+				}
+
+				log.info(`Attempting to use tasks file path: ${tasksJsonPath}`);
+
 				const result = await showTaskDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id
 					},
 					log
 				);

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { listTasksDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the getTasks tool with the MCP server
@@ -39,33 +40,47 @@ export function registerListTasksTool(server) {
 				),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: automatically detected from session or CWD)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Getting tasks with filters: ${JSON.stringify(args)}`);
-				// await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						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}`
+					);
 				}
 
 				const result = await listTasksDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						tasksJsonPath: tasksJsonPath,
+						status: args.status,
+						withSubtasks: args.withSubtasks
 					},
-					log /*, { reportProgress, mcpLog: log, session}*/
+					log
 				);
 
-				// await reportProgress({ progress: 100 });
-
 				log.info(
 					`Retrieved ${result.success ? result.data?.tasks?.length || 0 : 0} tasks${result.fromCache ? ' (from cache)' : ''}`
 				);

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { nextTaskDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the next-task tool with the MCP server
@@ -24,33 +25,46 @@ export function registerNextTaskTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Finding next task with args: ${JSON.stringify(args)}`);
-				// await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await nextTaskDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath
+						// No other args specific to this tool
 					},
-					log /*, { reportProgress, mcpLog: log, session}*/
+					log
 				);
 
-				// await reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(
 						`Successfully found next task: ${result.data?.task?.id || 'No available tasks'}`

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

@@ -5,11 +5,16 @@
 
 import { z } from 'zod';
 import {
+	getProjectRootFromSession,
 	handleApiResult,
-	createErrorResponse,
-	getProjectRootFromSession
+	createErrorResponse
 } from './utils.js';
 import { parsePRDDirect } from '../core/task-master-core.js';
+import {
+	resolveProjectPaths,
+	findPRDDocumentPath,
+	resolveTasksOutputPath
+} from '../core/utils/path-utils.js';
 
 /**
  * Register the parsePRD tool with the MCP server
@@ -23,6 +28,7 @@ export function registerParsePRDTool(server) {
 		parameters: z.object({
 			input: z
 				.string()
+				.optional()
 				.default('scripts/prd.txt')
 				.describe('Absolute path to the PRD document file (.txt, .md, etc.)'),
 			numTasks: z
@@ -35,7 +41,7 @@ export function registerParsePRDTool(server) {
 				.string()
 				.optional()
 				.describe(
-					'Output absolute path for tasks.json file (default: tasks/tasks.json)'
+					'Output path for tasks.json file (default: tasks/tasks.json)'
 				),
 			force: z
 				.boolean()
@@ -43,39 +49,44 @@ export function registerParsePRDTool(server) {
 				.describe('Allow overwriting an existing tasks.json file.'),
 			projectRoot: z
 				.string()
-				.describe(
-					'Absolute path to the root directory of the project. Required - ALWAYS SET THIS TO THE PROJECT ROOT DIRECTORY.'
-				)
+				.describe('The directory of the project. Must be absolute path.')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Parsing PRD with args: ${JSON.stringify(args)}`);
 
-				// Make sure projectRoot is passed directly in args or derive from session
-				// We prioritize projectRoot from args over session-derived path
-				let rootFolder = args.projectRoot;
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				// Only if args.projectRoot is undefined or null, try to get it from session
 				if (!rootFolder) {
-					log.warn(
-						'projectRoot not provided in args, attempting to derive from session'
+					return createErrorResponse(
+						'Could not determine project root. Please provide it explicitly or ensure your session contains valid root information.'
 					);
-					rootFolder = getProjectRootFromSession(session, log);
-
-					if (!rootFolder) {
-						const errorMessage =
-							'Could not determine project root directory. Please provide projectRoot parameter.';
-						log.error(errorMessage);
-						return createErrorResponse(errorMessage);
-					}
 				}
 
-				log.info(`Using project root: ${rootFolder} for PRD parsing`);
+				// Resolve input (PRD) and output (tasks.json) paths using the utility
+				const { projectRoot, prdPath, tasksJsonPath } = resolveProjectPaths(
+					rootFolder,
+					args,
+					log
+				);
 
+				// Check if PRD path was found (resolveProjectPaths returns null if not found and not provided)
+				if (!prdPath) {
+					return createErrorResponse(
+						'No PRD document found or provided. Please ensure a PRD file exists (e.g., PRD.md) or provide a valid input file path.'
+					);
+				}
+
+				// Call the direct function with fully resolved paths
 				const result = await parsePRDDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						projectRoot: projectRoot,
+						input: prdPath,
+						output: tasksJsonPath,
+						numTasks: args.numTasks,
+						force: args.force
 					},
 					log,
 					{ session }

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { removeDependencyDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the removeDependency tool with the MCP server
@@ -30,35 +31,50 @@ export function registerRemoveDependencyTool(server) {
 				),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(
 					`Removing dependency for task ${args.id} from ${args.dependsOn} with args: ${JSON.stringify(args)}`
 				);
-				// await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await removeDependencyDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						dependsOn: args.dependsOn
 					},
-					log /*, { reportProgress, mcpLog: log, session}*/
+					log
 				);
 
-				// await reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(`Successfully removed dependency: ${result.data.message}`);
 				} else {

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { removeSubtaskDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the removeSubtask tool with the MCP server
@@ -43,33 +44,49 @@ export function registerRemoveSubtaskTool(server) {
 				.describe('Skip regenerating task files'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Removing subtask with args: ${JSON.stringify(args)}`);
-				// await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await removeSubtaskDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						convert: args.convert,
+						skipGenerate: args.skipGenerate
 					},
-					log /*, { reportProgress, mcpLog: log, session}*/
+					log
 				);
 
-				// await reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(`Subtask removed successfully: ${result.data.message}`);
 				} else {

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { removeTaskDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the remove-task tool with the MCP server
@@ -26,10 +27,7 @@ export function registerRemoveTaskTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				),
+				.describe('The directory of the project. Must be an absolute path.'),
 			confirm: z
 				.boolean()
 				.optional()
@@ -39,28 +37,40 @@ export function registerRemoveTaskTool(server) {
 			try {
 				log.info(`Removing task with ID: ${args.id}`);
 
-				// Get project root from session
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
-				} else if (!rootFolder) {
-					// Ensure we have a default if nothing else works
-					rootFolder = process.cwd();
-					log.warn(
-						`Session and args failed to provide root, using CWD: ${rootFolder}`
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
+				}
+
+				log.info(`Using tasks file path: ${tasksJsonPath}`);
+
 				// Assume client has already handled confirmation if needed
 				const result = await removeTaskDirect(
 					{
-						id: args.id,
-						file: args.file,
-						projectRoot: rootFolder
+						tasksJsonPath: tasksJsonPath,
+						id: args.id
 					},
 					log
 				);

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { setTaskStatusDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the setTaskStatus tool with the MCP server
@@ -33,28 +34,45 @@ export function registerSetTaskStatusTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: automatically detected)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Setting status of task(s) ${args.id} to: ${args.status}`);
 
-				// Get project root from session
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 with the project root
+				// Resolve the path to tasks.json
+				let tasksJsonPath;
+				try {
+					tasksJsonPath = findTasksJsonPath(
+						{ projectRoot: rootFolder, file: args.file },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
+				}
+
+				// Call the direct function with the resolved path
 				const result = await setTaskStatusDirect(
 					{
-						...args,
-						projectRoot: rootFolder
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						status: args.status
 					},
 					log
 				);

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { updateSubtaskByIdDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the update-subtask tool with the MCP server
@@ -19,12 +20,12 @@ export function registerUpdateSubtaskTool(server) {
 	server.addTool({
 		name: 'update_subtask',
 		description:
-			'Appends additional information to a specific subtask without replacing existing content',
+			'Appends timestamped information to a specific subtask without replacing existing content',
 		parameters: z.object({
 			id: z
 				.string()
 				.describe(
-					'ID of the subtask to update in format "parentId.subtaskId" (e.g., "5.2")'
+					'ID of the subtask to update in format "parentId.subtaskId" (e.g., "5.2"). Parent ID is the ID of the task that contains the subtask.'
 				),
 			prompt: z.string().describe('Information to add to the subtask'),
 			research: z
@@ -34,26 +35,45 @@ export function registerUpdateSubtaskTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await updateSubtaskByIdDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						prompt: args.prompt,
+						research: args.research
 					},
 					log,
 					{ session }

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { updateTaskByIdDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the update-task tool with the MCP server
@@ -23,7 +24,9 @@ export function registerUpdateTaskTool(server) {
 		parameters: z.object({
 			id: z
 				.string()
-				.describe("ID of the task or subtask (e.g., '15', '15.2') to update"),
+				.describe(
+					"ID of the task (e.g., '15') to update. Subtasks are supported using the update-subtask tool."
+				),
 			prompt: z
 				.string()
 				.describe('New information or context to incorporate into the task'),
@@ -34,26 +37,45 @@ export function registerUpdateTaskTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Updating task with args: ${JSON.stringify(args)}`);
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await updateTaskByIdDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						// Pass the explicitly resolved path
+						tasksJsonPath: tasksJsonPath,
+						// Pass other relevant args
+						id: args.id,
+						prompt: args.prompt,
+						research: args.research
 					},
 					log,
 					{ session }

mcp-server/src/tools/update.js

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { updateTasksDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the update tool with the MCP server
@@ -19,7 +20,7 @@ export function registerUpdateTool(server) {
 	server.addTool({
 		name: 'update',
 		description:
-			"Update multiple upcoming tasks (with ID >= 'from' ID) based on new context or changes provided in the prompt. Use 'update_task' instead for a single specific task.",
+			"Update multiple upcoming tasks (with ID >= 'from' ID) based on new context or changes provided in the prompt. Use 'update_task' instead for a single specific task or 'update_subtask' for subtasks.",
 		parameters: z.object({
 			from: z
 				.string()
@@ -36,26 +37,43 @@ export function registerUpdateTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
 		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Updating tasks with args: ${JSON.stringify(args)}`);
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				// 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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await updateTasksDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						tasksJsonPath: tasksJsonPath,
+						from: args.from,
+						prompt: args.prompt,
+						research: args.research
 					},
 					log,
 					{ session }

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

@@ -10,6 +10,7 @@ import {
 	getProjectRootFromSession
 } from './utils.js';
 import { validateDependenciesDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the validateDependencies tool with the MCP server
@@ -24,34 +25,42 @@ export function registerValidateDependenciesTool(server) {
 			file: z.string().optional().describe('Absolute path to the tasks file'),
 			projectRoot: z
 				.string()
-				.optional()
-				.describe(
-					'Root directory of the project (default: current working directory)'
-				)
+				.describe('The directory of the project. Must be an absolute path.')
 		}),
-		execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(`Validating dependencies with args: ${JSON.stringify(args)}`);
-				await reportProgress({ progress: 0 });
 
-				let rootFolder = getProjectRootFromSession(session, log);
+				// Get project root from args or session
+				const rootFolder =
+					args.projectRoot || getProjectRootFromSession(session, log);
 
-				if (!rootFolder && args.projectRoot) {
-					rootFolder = args.projectRoot;
-					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				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 },
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding tasks.json: ${error.message}`);
+					return createErrorResponse(
+						`Failed to find tasks.json: ${error.message}`
+					);
 				}
 
 				const result = await validateDependenciesDirect(
 					{
-						projectRoot: rootFolder,
-						...args
+						tasksJsonPath: tasksJsonPath
 					},
-					log,
-					{ reportProgress, mcpLog: log, session }
+					log
 				);
 
-				await reportProgress({ progress: 100 });
-
 				if (result.success) {
 					log.info(
 						`Successfully validated dependencies: ${result.data.message}`

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "task-master-ai",
-  "version": "0.10.1",
+	"version": "0.11.1",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "task-master-ai",
-      "version": "0.10.1",
+			"version": "0.11.1",
 			"license": "MIT WITH Commons-Clause",
 			"dependencies": {
 				"@anthropic-ai/sdk": "^0.39.0",
@@ -31,6 +31,7 @@
 			},
 			"bin": {
 				"task-master": "bin/task-master.js",
+				"task-master-ai": "mcp-server/server.js",
 				"task-master-mcp": "mcp-server/server.js"
 			},
 			"devDependencies": {

package.json

@@ -1,12 +1,13 @@
 {
 	"name": "task-master-ai",
-	"version": "0.10.1",
+	"version": "0.11.1",
 	"description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
 	"main": "index.js",
 	"type": "module",
 	"bin": {
 		"task-master": "bin/task-master.js",
-		"task-master-mcp": "mcp-server/server.js"
+		"task-master-mcp": "mcp-server/server.js",
+		"task-master-ai": "mcp-server/server.js"
 	},
 	"scripts": {
 		"test": "node --experimental-vm-modules node_modules/.bin/jest",

scripts/init.js

@@ -23,23 +23,7 @@ import chalk from 'chalk';
 import figlet from 'figlet';
 import boxen from 'boxen';
 import gradient from 'gradient-string';
-import {
-	isSilentMode,
-	enableSilentMode,
-	disableSilentMode
-} from './modules/utils.js';
-
-// Only log if not in silent mode
-if (!isSilentMode()) {
-	console.log('Starting task-master-ai...');
-}
-
-// Debug information - only log if not in silent mode
-if (!isSilentMode()) {
-	console.log('Node version:', process.version);
-	console.log('Current directory:', process.cwd());
-	console.log('Script path:', import.meta.url);
-}
+import { isSilentMode } from './modules/utils.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -909,14 +893,14 @@ function setupMCPConfiguration(targetDir, projectName) {
 	const newMCPServer = {
 		'task-master-ai': {
 			command: 'npx',
-			args: ['-y', '--package', 'task-master-ai', 'task-master-mcp'],
+			args: ['-y', 'task-master-mcp'],
 			env: {
-				ANTHROPIC_API_KEY: '%ANTHROPIC_API_KEY%',
-				PERPLEXITY_API_KEY: '%PERPLEXITY_API_KEY%',
+				ANTHROPIC_API_KEY: 'YOUR_ANTHROPIC_API_KEY',
+				PERPLEXITY_API_KEY: 'YOUR_PERPLEXITY_API_KEY',
 				MODEL: 'claude-3-7-sonnet-20250219',
 				PERPLEXITY_MODEL: 'sonar-pro',
 				MAX_TOKENS: 64000,
-				TEMPERATURE: 0.3,
+				TEMPERATURE: 0.2,
 				DEFAULT_SUBTASKS: 5,
 				DEFAULT_PRIORITY: 'medium'
 			}
@@ -925,7 +909,10 @@ function setupMCPConfiguration(targetDir, projectName) {
 
 	// Check if mcp.json already exists
 	if (fs.existsSync(mcpJsonPath)) {
-		log('info', 'MCP configuration file already exists, updating...');
+		log(
+			'info',
+			'MCP configuration file already exists, checking for existing task-master-mcp...'
+		);
 		try {
 			// Read existing config
 			const mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));
@@ -935,6 +922,23 @@ function setupMCPConfiguration(targetDir, projectName) {
 				mcpConfig.mcpServers = {};
 			}
 
+			// Check if any existing server configuration already has task-master-mcp in its args
+			const hasMCPString = Object.values(mcpConfig.mcpServers).some(
+				(server) =>
+					server.args &&
+					server.args.some(
+						(arg) => typeof arg === 'string' && arg.includes('task-master-mcp')
+					)
+			);
+
+			if (hasMCPString) {
+				log(
+					'info',
+					'Found existing task-master-mcp configuration in mcp.json, leaving untouched'
+				);
+				return; // Exit early, don't modify the existing configuration
+			}
+
 			// Add the task-master-ai server if it doesn't exist
 			if (!mcpConfig.mcpServers['task-master-ai']) {
 				mcpConfig.mcpServers['task-master-ai'] = newMCPServer['task-master-ai'];

scripts/modules/dependency-manager.js

@@ -14,7 +14,8 @@ import {
 	writeJSON,
 	taskExists,
 	formatTaskId,
-	findCycles
+	findCycles,
+	isSilentMode
 } from './utils.js';
 
 import { displayBanner } from './ui.js';
@@ -320,6 +321,7 @@ async function removeDependency(tasksPath, taskId, dependencyId) {
 		`Removed dependency: Task ${formattedTaskId} no longer depends on ${formattedDependencyId}`
 	);
 
+	if (!isSilentMode()) {
 		// Display a more visually appealing success message
 		console.log(
 			boxen(
@@ -333,6 +335,7 @@ async function removeDependency(tasksPath, taskId, dependencyId) {
 				}
 			)
 		);
+	}
 
 	// Regenerate task files
 	await generateTaskFiles(tasksPath, 'tasks');
@@ -553,8 +556,11 @@ function cleanupSubtaskDependencies(tasksData) {
  * Validate dependencies in task files
  * @param {string} tasksPath - Path to tasks.json
  */
-async function validateDependenciesCommand(tasksPath) {
+async function validateDependenciesCommand(tasksPath, options = {}) {
+	// Only display banner if not in silent mode
+	if (!isSilentMode()) {
 		displayBanner();
+	}
 
 	log('info', 'Checking for invalid dependencies in task files...');
 
@@ -659,7 +665,8 @@ async function validateDependenciesCommand(tasksPath) {
 		if (changesDetected) {
 			log('success', 'Invalid dependencies were removed from tasks.json');
 
-			// Show detailed stats in a nice box
+			// Show detailed stats in a nice box - only if not in silent mode
+			if (!isSilentMode()) {
 				console.log(
 					boxen(
 						chalk.green(`Dependency Validation Results:\n\n`) +
@@ -685,6 +692,7 @@ async function validateDependenciesCommand(tasksPath) {
 						console.log(`  ${warning}`);
 					});
 				}
+			}
 
 			// Regenerate task files to reflect the changes
 			await generateTaskFiles(tasksPath, path.dirname(tasksPath));
@@ -695,7 +703,8 @@ async function validateDependenciesCommand(tasksPath) {
 				'No invalid dependencies found - all dependencies are valid'
 			);
 
-			// Show validation summary
+			// Show validation summary - only if not in silent mode
+			if (!isSilentMode()) {
 				console.log(
 					boxen(
 						chalk.green(`All Dependencies Are Valid\n\n`) +
@@ -711,6 +720,7 @@ async function validateDependenciesCommand(tasksPath) {
 					)
 				);
 			}
+		}
 	} catch (error) {
 		log('error', 'Error validating dependencies:', error);
 		process.exit(1);
@@ -747,9 +757,13 @@ function countAllDependencies(tasks) {
 /**
  * Fixes invalid dependencies in tasks.json
  * @param {string} tasksPath - Path to tasks.json
+ * @param {Object} options - Options object
  */
-async function fixDependenciesCommand(tasksPath) {
+async function fixDependenciesCommand(tasksPath, options = {}) {
+	// Only display banner if not in silent mode
+	if (!isSilentMode()) {
 		displayBanner();
+	}
 
 	log('info', 'Checking for and fixing invalid dependencies in tasks.json...');
 
@@ -1086,6 +1100,7 @@ async function fixDependenciesCommand(tasksPath) {
 			stats.duplicateDependenciesRemoved +
 			stats.circularDependenciesFixed;
 
+		if (!isSilentMode()) {
 			if (totalFixedAll > 0) {
 				log('success', `Fixed ${totalFixedAll} dependency issues in total!`);
 
@@ -1107,7 +1122,10 @@ async function fixDependenciesCommand(tasksPath) {
 					)
 				);
 			} else {
-			log('success', 'No dependency issues found - all dependencies are valid');
+				log(
+					'success',
+					'No dependency issues found - all dependencies are valid'
+				);
 
 				console.log(
 					boxen(
@@ -1123,6 +1141,7 @@ async function fixDependenciesCommand(tasksPath) {
 					)
 				);
 			}
+		}
 	} catch (error) {
 		log('error', 'Error in fix-dependencies command:', error);
 		process.exit(1);

tasks/task_060.txt

@@ -1,39 +1,73 @@
 # Task ID: 60
-# Title: Implement isValidTaskId Utility Function
+# Title: Implement Mentor System with Round-Table Discussion Feature
 # Status: pending
 # Dependencies: None
 # Priority: medium
-# Description: Create a utility function that validates whether a given string conforms to the project's task ID format specification.
+# Description: Create a mentor system that allows users to add simulated mentors to their projects and facilitate round-table discussions between these mentors to gain diverse perspectives and insights on tasks.
 # Details:
-Develop a function named `isValidTaskId` that takes a string parameter and returns a boolean indicating whether the string matches our task ID format. The task ID format follows these rules:
+Implement a comprehensive mentor system with the following features:
 
-1. Must start with 'TASK-' prefix (case-sensitive)
-2. Followed by a numeric value (at least 1 digit)
-3. The numeric portion should not have leading zeros (unless it's just zero)
-4. The total length should be between 6 and 12 characters inclusive
+1. **Mentor Management**:
+   - Create a `mentors.json` file to store mentor data including name, personality, expertise, and other relevant attributes
+   - Implement `add-mentor` command that accepts a name and prompt describing the mentor's characteristics
+   - Implement `remove-mentor` command to delete mentors from the system
+   - Implement `list-mentors` command to display all configured mentors and their details
+   - Set a recommended maximum of 5 mentors with appropriate warnings
 
-Example valid IDs: 'TASK-1', 'TASK-42', 'TASK-1000'
-Example invalid IDs: 'task-1' (wrong case), 'TASK-' (missing number), 'TASK-01' (leading zero), 'TASK-A1' (non-numeric), 'TSK-1' (wrong prefix)
+2. **Round-Table Discussion**:
+   - Create a `round-table` command with the following parameters:
+     - `--prompt`: Optional text prompt to guide the discussion
+     - `--id`: Optional task/subtask ID(s) to provide context (support comma-separated values)
+     - `--turns`: Number of discussion rounds (each mentor speaks once per turn)
+     - `--output`: Optional flag to export results to a file
+   - Implement an interactive CLI experience using inquirer for the round-table
+   - Generate a simulated discussion where each mentor speaks in turn based on their personality
+   - After all turns complete, generate insights, recommendations, and a summary
+   - Display results in the CLI
+   - When `--output` is specified, create a `round-table.txt` file containing:
+     - Initial prompt
+     - Target task ID(s)
+     - Full round-table discussion transcript
+     - Recommendations and insights section
 
-The function should be placed in the utilities directory and properly exported. Include JSDoc comments for clear documentation of parameters and return values.
+3. **Integration with Task System**:
+   - Enhance `update`, `update-task`, and `update-subtask` commands to accept a round-table.txt file
+   - Use the round-table output as input for updating tasks or subtasks
+   - Allow appending round-table insights to subtasks
+
+4. **LLM Integration**:
+   - Configure the system to effectively simulate different personalities using LLM
+   - Ensure mentors maintain consistent personalities across different round-tables
+   - Implement proper context handling to ensure relevant task information is included
+
+Ensure all commands have proper help text and error handling for cases like no mentors configured, invalid task IDs, etc.
 
 # Test Strategy:
-Testing should include the following cases:
+1. **Unit Tests**:
+   - Test mentor data structure creation and validation
+   - Test mentor addition with various input formats
+   - Test mentor removal functionality
+   - Test listing of mentors with different configurations
+   - Test round-table parameter parsing and validation
 
-1. Valid task IDs:
-   - 'TASK-1'
-   - 'TASK-123'
-   - 'TASK-9999'
+2. **Integration Tests**:
+   - Test the complete flow of adding mentors and running a round-table
+   - Test round-table with different numbers of turns
+   - Test round-table with task context vs. custom prompt
+   - Test output file generation and format
+   - Test using round-table output to update tasks and subtasks
 
-2. Invalid task IDs:
-   - Null or undefined input
-   - Empty string
-   - 'task-1' (lowercase prefix)
-   - 'TASK-' (missing number)
-   - 'TASK-01' (leading zero)
-   - 'TASK-ABC' (non-numeric suffix)
-   - 'TSK-1' (incorrect prefix)
-   - 'TASK-12345678901' (too long)
-   - 'TASK1' (missing hyphen)
+3. **Edge Cases**:
+   - Test behavior when no mentors are configured but round-table is called
+   - Test with invalid task IDs in the --id parameter
+   - Test with extremely long discussions (many turns)
+   - Test with mentors that have similar personalities
+   - Test removing a mentor that doesn't exist
+   - Test adding more than the recommended 5 mentors
 
-Implement unit tests using the project's testing framework. Each test case should have a clear assertion message explaining why the test failed if it does. Also include edge cases such as strings with whitespace ('TASK- 1') or special characters ('TASK-1#').
+4. **Manual Testing Scenarios**:
+   - Create mentors with distinct personalities (e.g., Vitalik Buterin, Steve Jobs, etc.)
+   - Run a round-table on a complex task and verify the insights are helpful
+   - Verify the personality simulation is consistent and believable
+   - Test the round-table output file readability and usefulness
+   - Verify that using round-table output to update tasks produces meaningful improvements

tasks/tasks.json

@@ -2729,10 +2729,10 @@
     },
     {
       "id": 60,
-      "title": "Implement isValidTaskId Utility Function",
-      "description": "Create a utility function that validates whether a given string conforms to the project's task ID format specification.",
-      "details": "Develop a function named `isValidTaskId` that takes a string parameter and returns a boolean indicating whether the string matches our task ID format. The task ID format follows these rules:\n\n1. Must start with 'TASK-' prefix (case-sensitive)\n2. Followed by a numeric value (at least 1 digit)\n3. The numeric portion should not have leading zeros (unless it's just zero)\n4. The total length should be between 6 and 12 characters inclusive\n\nExample valid IDs: 'TASK-1', 'TASK-42', 'TASK-1000'\nExample invalid IDs: 'task-1' (wrong case), 'TASK-' (missing number), 'TASK-01' (leading zero), 'TASK-A1' (non-numeric), 'TSK-1' (wrong prefix)\n\nThe function should be placed in the utilities directory and properly exported. Include JSDoc comments for clear documentation of parameters and return values.",
-      "testStrategy": "Testing should include the following cases:\n\n1. Valid task IDs:\n   - 'TASK-1'\n   - 'TASK-123'\n   - 'TASK-9999'\n\n2. Invalid task IDs:\n   - Null or undefined input\n   - Empty string\n   - 'task-1' (lowercase prefix)\n   - 'TASK-' (missing number)\n   - 'TASK-01' (leading zero)\n   - 'TASK-ABC' (non-numeric suffix)\n   - 'TSK-1' (incorrect prefix)\n   - 'TASK-12345678901' (too long)\n   - 'TASK1' (missing hyphen)\n\nImplement unit tests using the project's testing framework. Each test case should have a clear assertion message explaining why the test failed if it does. Also include edge cases such as strings with whitespace ('TASK- 1') or special characters ('TASK-1#').",
+      "title": "Implement Mentor System with Round-Table Discussion Feature",
+      "description": "Create a mentor system that allows users to add simulated mentors to their projects and facilitate round-table discussions between these mentors to gain diverse perspectives and insights on tasks.",
+      "details": "Implement a comprehensive mentor system with the following features:\n\n1. **Mentor Management**:\n   - Create a `mentors.json` file to store mentor data including name, personality, expertise, and other relevant attributes\n   - Implement `add-mentor` command that accepts a name and prompt describing the mentor's characteristics\n   - Implement `remove-mentor` command to delete mentors from the system\n   - Implement `list-mentors` command to display all configured mentors and their details\n   - Set a recommended maximum of 5 mentors with appropriate warnings\n\n2. **Round-Table Discussion**:\n   - Create a `round-table` command with the following parameters:\n     - `--prompt`: Optional text prompt to guide the discussion\n     - `--id`: Optional task/subtask ID(s) to provide context (support comma-separated values)\n     - `--turns`: Number of discussion rounds (each mentor speaks once per turn)\n     - `--output`: Optional flag to export results to a file\n   - Implement an interactive CLI experience using inquirer for the round-table\n   - Generate a simulated discussion where each mentor speaks in turn based on their personality\n   - After all turns complete, generate insights, recommendations, and a summary\n   - Display results in the CLI\n   - When `--output` is specified, create a `round-table.txt` file containing:\n     - Initial prompt\n     - Target task ID(s)\n     - Full round-table discussion transcript\n     - Recommendations and insights section\n\n3. **Integration with Task System**:\n   - Enhance `update`, `update-task`, and `update-subtask` commands to accept a round-table.txt file\n   - Use the round-table output as input for updating tasks or subtasks\n   - Allow appending round-table insights to subtasks\n\n4. **LLM Integration**:\n   - Configure the system to effectively simulate different personalities using LLM\n   - Ensure mentors maintain consistent personalities across different round-tables\n   - Implement proper context handling to ensure relevant task information is included\n\nEnsure all commands have proper help text and error handling for cases like no mentors configured, invalid task IDs, etc.",
+      "testStrategy": "1. **Unit Tests**:\n   - Test mentor data structure creation and validation\n   - Test mentor addition with various input formats\n   - Test mentor removal functionality\n   - Test listing of mentors with different configurations\n   - Test round-table parameter parsing and validation\n\n2. **Integration Tests**:\n   - Test the complete flow of adding mentors and running a round-table\n   - Test round-table with different numbers of turns\n   - Test round-table with task context vs. custom prompt\n   - Test output file generation and format\n   - Test using round-table output to update tasks and subtasks\n\n3. **Edge Cases**:\n   - Test behavior when no mentors are configured but round-table is called\n   - Test with invalid task IDs in the --id parameter\n   - Test with extremely long discussions (many turns)\n   - Test with mentors that have similar personalities\n   - Test removing a mentor that doesn't exist\n   - Test adding more than the recommended 5 mentors\n\n4. **Manual Testing Scenarios**:\n   - Create mentors with distinct personalities (e.g., Vitalik Buterin, Steve Jobs, etc.)\n   - Run a round-table on a complex task and verify the insights are helpful\n   - Verify the personality simulation is consistent and believable\n   - Test the round-table output file readability and usefulness\n   - Verify that using round-table output to update tasks produces meaningful improvements",
       "status": "pending",
       "dependencies": [],
       "priority": "medium"

tests/integration/mcp-server/direct-functions.test.js

@@ -131,7 +131,7 @@ jest.mock('../../../scripts/modules/utils.js', () => ({
 	enableSilentMode: mockEnableSilentMode,
 	disableSilentMode: mockDisableSilentMode,
 	CONFIG: {
-		model: 'claude-3-sonnet-20240229',
+		model: 'claude-3-7-sonnet-20250219',
 		maxTokens: 64000,
 		temperature: 0.2,
 		defaultSubtasks: 5

tests/setup.js

@@ -7,10 +7,10 @@
 // Mock environment variables
 process.env.MODEL = 'sonar-pro';
 process.env.MAX_TOKENS = '64000';
-process.env.TEMPERATURE = '0.4';
+process.env.TEMPERATURE = '0.2';
 process.env.DEBUG = 'false';
 process.env.LOG_LEVEL = 'error'; // Set to error to reduce noise in tests
-process.env.DEFAULT_SUBTASKS = '3';
+process.env.DEFAULT_SUBTASKS = '5';
 process.env.DEFAULT_PRIORITY = 'medium';
 process.env.PROJECT_NAME = 'Test Project';
 process.env.PROJECT_VERSION = '1.0.0';