chore: add contributing.md

* fix: claude-4 not having the right max_tokens

* feat: add bedrock support

* chore: fix package-lock.json

* fix: rename baseUrl to baseURL

* feat: add azure support

* fix: final touches of azure integration

* feat: add google vertex provider

* chore: fix tests and refactor task-manager.test.js

* chore: move task 92 to 94

.changeset/beige-doodles-type.md

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

.changeset/floppy-plants-marry.md

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

.changeset/forty-plums-stay.md

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

.changeset/hungry-geese-work.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': minor
+---
+
+Add AWS bedrock support

.changeset/itchy-taxes-sip.md

@@ -0,0 +1,13 @@
+---
+'task-master-ai': minor
+---
+
+# Add Google Vertex AI Provider Integration
+
+- Implemented `VertexAIProvider` class extending BaseAIProvider
+- Added authentication and configuration handling for Vertex AI
+- Updated configuration manager with Vertex-specific getters
+- Modified AI services unified system to integrate the provider
+- Added documentation for Vertex AI setup and configuration
+- Updated environment variable examples for Vertex AI support
+- Implemented specialized error handling for Vertex-specific issues

.changeset/lemon-apes-sort.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': minor
+---
+
+Add support for Azure

.changeset/many-wasps-sell.md

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

.changeset/plain-bottles-stand.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': minor
+---
+
+Renamed baseUrl to baseURL

.changeset/pre.json

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

.changeset/red-oranges-attend.md

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

.changeset/red-suns-wash.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Add src directory to exports

.changeset/shaggy-rice-exist.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Fix max_tokens error when trying to use claude-sonnet-4 and claude-opus-4

.changeset/sharp-dingos-melt.md

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

.changeset/sharp-flies-call.md

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

.changeset/six-cloths-happen.md

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

.changeset/slow-singers-swim.md

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

.changeset/social-masks-fold.md

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

.changeset/soft-zoos-flow.md

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

.changeset/ten-ways-mate.md

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

.changeset/tidy-seals-rule.md

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

.changeset/tricky-wombats-spend.md

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

.changeset/wide-eyes-relax.md

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

.cursor/rules/ai_services.mdc

@@ -25,6 +25,7 @@ This document outlines the architecture and usage patterns for interacting with
     *   Implements **retry logic** for specific API errors (`_attemptProviderCallWithRetries`).
     *   Resolves API keys automatically via `_resolveApiKey` (using `resolveEnvVariable`).
     *   Maps requests to the correct provider implementation (in `src/ai-providers/`) via `PROVIDER_FUNCTIONS`.
+    *   Returns a structured object containing the primary AI result (`mainResult`) and telemetry data (`telemetryData`). See [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc) for details on how this telemetry data is propagated and handled.
 
 *   **Provider Implementations (`src/ai-providers/*.js`):**
     *   Contain provider-specific wrappers around Vercel AI SDK functions (`generateText`, `generateObject`).

.cursor/rules/architecture.mdc

@@ -42,6 +42,7 @@ alwaysApply: false
       - Resolves API keys (from `.env` or `session.env`).
       - Implements fallback and retry logic.
       - Orchestrates calls to provider-specific implementations (`src/ai-providers/`).
+    - Telemetry data generated by the AI service layer is propagated upwards through core logic, direct functions, and MCP tools. See [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc) for the detailed integration pattern.
 
   - **[`src/ai-providers/*.js`](mdc:src/ai-providers/): Provider-Specific Implementations**
     - **Purpose**: Provider-specific wrappers for Vercel AI SDK functions.

.cursor/rules/dev_workflow.mdc

@@ -49,6 +49,7 @@ Task Master offers two primary ways to interact:
 -   Maintain valid dependency structure with `add_dependency`/`remove_dependency` tools or `task-master add-dependency`/`remove-dependency` commands, `validate_dependencies` / `task-master validate-dependencies`, and `fix_dependencies` / `task-master fix-dependencies` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) when needed
 -   Respect dependency chains and task priorities when selecting work
 -   Report progress regularly using `get_tasks` / `task-master list`
+-   Reorganize tasks as needed using `move_task` / `task-master move --from=<id> --to=<id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to change task hierarchy or ordering
 
 ## Task Complexity Analysis
 
@@ -154,6 +155,25 @@ Taskmaster configuration is managed through two main mechanisms:
 - Task files are automatically regenerated after dependency changes
 - Dependencies are visualized with status indicators in task listings and files
 
+## Task Reorganization
+
+- Use `move_task` / `task-master move --from=<id> --to=<id>` to move tasks or subtasks within the hierarchy
+- This command supports several use cases:
+  - Moving a standalone task to become a subtask (e.g., `--from=5 --to=7`)
+  - Moving a subtask to become a standalone task (e.g., `--from=5.2 --to=7`) 
+  - Moving a subtask to a different parent (e.g., `--from=5.2 --to=7.3`)
+  - Reordering subtasks within the same parent (e.g., `--from=5.2 --to=5.4`)
+  - Moving a task to a new, non-existent ID position (e.g., `--from=5 --to=25`)
+  - Moving multiple tasks at once using comma-separated IDs (e.g., `--from=10,11,12 --to=16,17,18`)
+- The system includes validation to prevent data loss:
+  - Allows moving to non-existent IDs by creating placeholder tasks
+  - Prevents moving to existing task IDs that have content (to avoid overwriting)
+  - Validates source tasks exist before attempting to move them
+- The system maintains proper parent-child relationships and dependency integrity
+- Task files are automatically regenerated after the move operation
+- This provides greater flexibility in organizing and refining your task structure as project understanding evolves
+- This is especially useful when dealing with potential merge conflicts arising from teams creating tasks on separate branches. Solve these conflicts very easily by moving your tasks and keeping theirs.
+
 ## Iterative Subtask Implementation
 
 Once a task has been broken down into subtasks using `expand_task` or similar methods, follow this iterative process for implementation:

.cursor/rules/glossary.mdc

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

.cursor/rules/mcp.mdc

@@ -522,3 +522,8 @@ Follow these steps to add MCP support for an existing Task Master command (see [
       // Add more functions as implemented
     };
     ```
+
+## Telemetry Integration
+
+- Direct functions calling core logic that involves AI should receive and pass through `telemetryData` within their successful `data` payload. See [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc) for the standard pattern.
+- MCP tools use `handleApiResult`, which ensures the `data` object (potentially including `telemetryData`) from the direct function is correctly included in the final response.

.cursor/rules/new_features.mdc

@@ -3,7 +3,6 @@ description: Guidelines for integrating new features into the Task Master CLI
 globs: scripts/modules/*.js
 alwaysApply: false
 ---
-
 # Task Master Feature Integration Guidelines
 
 ## Feature Placement Decision Process
@@ -196,6 +195,8 @@ The standard pattern for adding a feature follows this workflow:
   - ✅ **DO**: If an MCP tool fails with vague errors (e.g., JSON parsing issues like `Unexpected token ... is not valid JSON`), **try running the equivalent CLI command directly in the terminal** (e.g., `task-master expand --all`). CLI output often provides much more specific error messages (like missing function definitions or stack traces from the core logic) that pinpoint the root cause.
   - ❌ **DON'T**: Rely solely on MCP logs if the error is unclear; use the CLI as a complementary debugging tool for core logic issues.
 
+- **Telemetry Integration**: Ensure AI calls correctly handle and propagate `telemetryData` as described in [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc).
+
 ```javascript
 // 1. CORE LOGIC: Add function to appropriate module (example in task-manager.js)
 /**

.cursor/rules/taskmaster.mdc

@@ -269,11 +269,36 @@ This document provides a detailed reference for interacting with Taskmaster, cov
     *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
 *   **Usage:** Delete unnecessary subtasks or promote a subtask to a top-level task.
 
+### 17. Move Task (`move_task`)
+
+*   **MCP Tool:** `move_task`
+*   **CLI Command:** `task-master move [options]`
+*   **Description:** `Move a task or subtask to a new position within the task hierarchy.`
+*   **Key Parameters/Options:**
+    *   `from`: `Required. ID of the task/subtask to move (e.g., "5" or "5.2"). Can be comma-separated for multiple tasks.` (CLI: `--from <id>`)
+    *   `to`: `Required. ID of the destination (e.g., "7" or "7.3"). Must match the number of source IDs if comma-separated.` (CLI: `--to <id>`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+*   **Usage:** Reorganize tasks by moving them within the hierarchy. Supports various scenarios like:
+    *   Moving a task to become a subtask
+    *   Moving a subtask to become a standalone task
+    *   Moving a subtask to a different parent
+    *   Reordering subtasks within the same parent
+    *   Moving a task to a new, non-existent ID (automatically creates placeholders)
+    *   Moving multiple tasks at once with comma-separated IDs
+*   **Validation Features:**
+    *   Allows moving tasks to non-existent destination IDs (creates placeholder tasks)
+    *   Prevents moving to existing task IDs that already have content (to avoid overwriting)
+    *   Validates that source tasks exist before attempting to move them
+    *   Maintains proper parent-child relationships
+*   **Example CLI:** `task-master move --from=5.2 --to=7.3` to move subtask 5.2 to become subtask 7.3.
+*   **Example Multi-Move:** `task-master move --from=10,11,12 --to=16,17,18` to move multiple tasks to new positions.
+*   **Common Use:** Resolving merge conflicts in tasks.json when multiple team members create tasks on different branches.
+
 ---
 
 ## Dependency Management
 
-### 17. Add Dependency (`add_dependency`)
+### 18. Add Dependency (`add_dependency`)
 
 *   **MCP Tool:** `add_dependency`
 *   **CLI Command:** `task-master add-dependency [options]`
@@ -284,7 +309,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
     *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <path>`)
 *   **Usage:** Establish the correct order of execution between tasks.
 
-### 18. Remove Dependency (`remove_dependency`)
+### 19. Remove Dependency (`remove_dependency`)
 
 *   **MCP Tool:** `remove_dependency`
 *   **CLI Command:** `task-master remove-dependency [options]`
@@ -295,7 +320,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
     *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
 *   **Usage:** Update task relationships when the order of execution changes.
 
-### 19. Validate Dependencies (`validate_dependencies`)
+### 20. Validate Dependencies (`validate_dependencies`)
 
 *   **MCP Tool:** `validate_dependencies`
 *   **CLI Command:** `task-master validate-dependencies [options]`
@@ -304,7 +329,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
     *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
 *   **Usage:** Audit the integrity of your task dependencies.
 
-### 20. Fix Dependencies (`fix_dependencies`)
+### 21. Fix Dependencies (`fix_dependencies`)
 
 *   **MCP Tool:** `fix_dependencies`
 *   **CLI Command:** `task-master fix-dependencies [options]`
@@ -317,7 +342,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 
 ## Analysis & Reporting
 
-### 21. Analyze Project Complexity (`analyze_project_complexity`)
+### 22. Analyze Project Complexity (`analyze_project_complexity`)
 
 *   **MCP Tool:** `analyze_project_complexity`
 *   **CLI Command:** `task-master analyze-complexity [options]`
@@ -330,7 +355,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **Usage:** Used before breaking down tasks to identify which ones need the most attention.
 *   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
 
-### 22. View Complexity Report (`complexity_report`)
+### 23. View Complexity Report (`complexity_report`)
 
 *   **MCP Tool:** `complexity_report`
 *   **CLI Command:** `task-master complexity-report [options]`
@@ -343,7 +368,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 
 ## File Management
 
-### 23. Generate Task Files (`generate`)
+### 24. Generate Task Files (`generate`)
 
 *   **MCP Tool:** `generate`
 *   **CLI Command:** `task-master generate [options]`

.cursor/rules/telemetry.mdc

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

.env.example

@@ -7,3 +7,9 @@ MISTRAL_API_KEY=YOUR_MISTRAL_KEY_HERE
 OPENROUTER_API_KEY=YOUR_OPENROUTER_KEY_HERE
 XAI_API_KEY=YOUR_XAI_KEY_HERE
 AZURE_OPENAI_API_KEY=YOUR_AZURE_KEY_HERE
+
+# Google Vertex AI Configuration
+VERTEX_PROJECT_ID=your-gcp-project-id
+VERTEX_LOCATION=us-central1
+# Optional: Path to service account credentials JSON file (alternative to API key)
+GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-credentials.json

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

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

.taskmasterconfig

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

CHANGELOG.md

@@ -1,5 +1,299 @@
 # task-master-ai
 
+## 0.15.0
+
+### Minor Changes
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`09add37`](https://github.com/eyaltoledano/claude-task-master/commit/09add37423d70b809d5c28f3cde9fccd5a7e64e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Added comprehensive Ollama model validation and interactive setup support
+
+  - **Interactive Setup Enhancement**: Added "Custom Ollama model" option to `task-master models --setup`, matching the existing OpenRouter functionality
+  - **Live Model Validation**: When setting Ollama models, Taskmaster now validates against the local Ollama instance by querying `/api/tags` endpoint
+  - **Configurable Endpoints**: Uses the `ollamaBaseUrl` from `.taskmasterconfig` (with role-specific `baseUrl` overrides supported)
+  - **Robust Error Handling**:
+    - Detects when Ollama server is not running and provides clear error messages
+    - Validates model existence and lists available alternatives when model not found
+    - Graceful fallback behavior for connection issues
+  - **Full Platform Support**: Both MCP server tools and CLI commands support the new validation
+  - **Improved User Experience**: Clear feedback during model validation with informative success/error messages
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`4c83526`](https://github.com/eyaltoledano/claude-task-master/commit/4c835264ac6c1f74896cddabc3b3c69a5c435417) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds and updates supported AI models with costs:
+
+  - Added new OpenRouter models: GPT-4.1 series, O3, Codex Mini, Llama 4 Maverick, Llama 4 Scout, Qwen3-235b
+  - Added Mistral models: Devstral Small, Mistral Nemo
+  - Updated Ollama models with latest variants: Devstral, Qwen3, Mistral-small3.1, Llama3.3
+  - Updated Gemini model to latest 2.5 Flash preview version
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`70f4054`](https://github.com/eyaltoledano/claude-task-master/commit/70f4054f268f9f8257870e64c24070263d4e2966) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add `--research` flag to parse-prd command, enabling enhanced task generation from PRD files. When used, Taskmaster leverages the research model to:
+
+  - Research current technologies and best practices relevant to the project
+  - Identify technical challenges and security concerns not explicitly mentioned in the PRD
+  - Include specific library recommendations with version numbers
+  - Provide more detailed implementation guidance based on industry standards
+  - Create more accurate dependency relationships between tasks
+
+  This results in higher quality, more actionable tasks with minimal additional effort.
+
+  _NOTE_ That this is an experimental feature. Research models don't typically do great at structured output. You may find some failures when using research mode, so please share your feedback so we can improve this.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`5e9bc28`](https://github.com/eyaltoledano/claude-task-master/commit/5e9bc28abea36ec7cd25489af7fcc6cbea51038b) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - This change significantly enhances the `add-task` command's intelligence. When you add a new task, Taskmaster now automatically: - Analyzes your existing tasks to find those most relevant to your new task's description. - Provides the AI with detailed context from these relevant tasks.
+
+  This results in newly created tasks being more accurately placed within your project's dependency structure, saving you time and any need to update tasks just for dependencies, all without significantly increasing AI costs. You'll get smarter, more connected tasks right from the start.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34c769b`](https://github.com/eyaltoledano/claude-task-master/commit/34c769bcd0faf65ddec3b95de2ba152a8be3ec5c) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Enhance analyze-complexity to support analyzing specific task IDs. - You can now analyze individual tasks or selected task groups by using the new `--id` option with comma-separated IDs, or `--from` and `--to` options to specify a range of tasks. - The feature intelligently merges analysis results with existing reports, allowing incremental analysis while preserving previous results.
+
+- [#558](https://github.com/eyaltoledano/claude-task-master/pull/558) [`86d8f00`](https://github.com/eyaltoledano/claude-task-master/commit/86d8f00af809887ee0ba0ba7157cc555e0d07c38) Thanks [@ShreyPaharia](https://github.com/ShreyPaharia)! - Add next task to set task status response
+  Status: DONE
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`04af16d`](https://github.com/eyaltoledano/claude-task-master/commit/04af16de27295452e134b17b3c7d0f44bbb84c29) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add move command to enable moving tasks and subtasks within the task hierarchy. This new command supports moving standalone tasks to become subtasks, subtasks to become standalone tasks, and moving subtasks between different parents. The implementation handles circular dependencies, validation, and proper updating of parent-child relationships.
+
+  **Usage:**
+
+  - CLI command: `task-master move --from=<id> --to=<id>`
+  - MCP tool: `move_task` with parameters:
+    - `from`: ID of task/subtask to move (e.g., "5" or "5.2")
+    - `to`: ID of destination (e.g., "7" or "7.3")
+    - `file` (optional): Custom path to tasks.json
+
+  **Example scenarios:**
+
+  - Move task to become subtask: `--from="5" --to="7"`
+  - Move subtask to standalone task: `--from="5.2" --to="7"`
+  - Move subtask to different parent: `--from="5.2" --to="7.3"`
+  - Reorder subtask within same parent: `--from="5.2" --to="5.4"`
+  - Move multiple tasks at once: `--from="10,11,12" --to="16,17,18"`
+  - Move task to new ID: `--from="5" --to="25"` (creates a new task with ID 25)
+
+  **Multiple Task Support:**
+  The command supports moving multiple tasks simultaneously by providing comma-separated lists for both `--from` and `--to` parameters. The number of source and destination IDs must match. This is particularly useful for resolving merge conflicts in task files when multiple team members have created tasks on different branches.
+
+  **Validation Features:**
+
+  - Allows moving tasks to new, non-existent IDs (automatically creates placeholders)
+  - Prevents moving to existing task IDs that already contain content (to avoid overwriting)
+  - Validates source tasks exist before attempting to move them
+  - Ensures proper parent-child relationships are maintained
+
+### Patch Changes
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`231e569`](https://github.com/eyaltoledano/claude-task-master/commit/231e569e84804a2e5ba1f9da1a985d0851b7e949) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adjusts default main model model to Claude Sonnet 4. Adjusts default fallback to Claude Sonney 3.7"
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`b371808`](https://github.com/eyaltoledano/claude-task-master/commit/b371808524f2c2986f4940d78fcef32c125d01f2) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds llms-install.md to the root to enable AI agents to programmatically install the Taskmaster MCP server. This is specifically being introduced for the Cline MCP marketplace and will be adjusted over time for other MCP clients as needed.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`a59dd03`](https://github.com/eyaltoledano/claude-task-master/commit/a59dd037cfebb46d38bc44dd216c7c23933be641) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds AGENTS.md to power Claude Code integration more natively based on Anthropic's best practice and Claude-specific MCP client behaviours. Also adds in advanced workflows that tie Taskmaster commands together into one Claude workflow."
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`e0e1155`](https://github.com/eyaltoledano/claude-task-master/commit/e0e115526089bf41d5d60929956edf5601ff3e23) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes issue with force/append flag combinations for parse-prd.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34df2c8`](https://github.com/eyaltoledano/claude-task-master/commit/34df2c8bbddc0e157c981d32502bbe6b9468202e) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - You can now add tasks to a newly initialized project without having to parse a prd. This will automatically create the missing tasks.json file and create the first task. Lets you vibe if you want to vibe."
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`d2e6431`](https://github.com/eyaltoledano/claude-task-master/commit/d2e64318e2f4bfc3457792e310cc4ff9210bba30) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue where the research fallback would attempt to make API calls without checking for a valid API key first. This ensures proper error handling when the main task generation and first fallback both fail. Closes #421 #519.
+
+## 0.15.0-rc.0
+
+### Minor Changes
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`09add37`](https://github.com/eyaltoledano/claude-task-master/commit/09add37423d70b809d5c28f3cde9fccd5a7e64e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Added comprehensive Ollama model validation and interactive setup support
+
+  - **Interactive Setup Enhancement**: Added "Custom Ollama model" option to `task-master models --setup`, matching the existing OpenRouter functionality
+  - **Live Model Validation**: When setting Ollama models, Taskmaster now validates against the local Ollama instance by querying `/api/tags` endpoint
+  - **Configurable Endpoints**: Uses the `ollamaBaseUrl` from `.taskmasterconfig` (with role-specific `baseUrl` overrides supported)
+  - **Robust Error Handling**:
+    - Detects when Ollama server is not running and provides clear error messages
+    - Validates model existence and lists available alternatives when model not found
+    - Graceful fallback behavior for connection issues
+  - **Full Platform Support**: Both MCP server tools and CLI commands support the new validation
+  - **Improved User Experience**: Clear feedback during model validation with informative success/error messages
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`4c83526`](https://github.com/eyaltoledano/claude-task-master/commit/4c835264ac6c1f74896cddabc3b3c69a5c435417) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds and updates supported AI models with costs:
+
+  - Added new OpenRouter models: GPT-4.1 series, O3, Codex Mini, Llama 4 Maverick, Llama 4 Scout, Qwen3-235b
+  - Added Mistral models: Devstral Small, Mistral Nemo
+  - Updated Ollama models with latest variants: Devstral, Qwen3, Mistral-small3.1, Llama3.3
+  - Updated Gemini model to latest 2.5 Flash preview version
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`70f4054`](https://github.com/eyaltoledano/claude-task-master/commit/70f4054f268f9f8257870e64c24070263d4e2966) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add `--research` flag to parse-prd command, enabling enhanced task generation from PRD files. When used, Taskmaster leverages the research model to:
+
+  - Research current technologies and best practices relevant to the project
+  - Identify technical challenges and security concerns not explicitly mentioned in the PRD
+  - Include specific library recommendations with version numbers
+  - Provide more detailed implementation guidance based on industry standards
+  - Create more accurate dependency relationships between tasks
+
+  This results in higher quality, more actionable tasks with minimal additional effort.
+
+  _NOTE_ That this is an experimental feature. Research models don't typically do great at structured output. You may find some failures when using research mode, so please share your feedback so we can improve this.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`5e9bc28`](https://github.com/eyaltoledano/claude-task-master/commit/5e9bc28abea36ec7cd25489af7fcc6cbea51038b) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - This change significantly enhances the `add-task` command's intelligence. When you add a new task, Taskmaster now automatically: - Analyzes your existing tasks to find those most relevant to your new task's description. - Provides the AI with detailed context from these relevant tasks.
+
+  This results in newly created tasks being more accurately placed within your project's dependency structure, saving you time and any need to update tasks just for dependencies, all without significantly increasing AI costs. You'll get smarter, more connected tasks right from the start.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34c769b`](https://github.com/eyaltoledano/claude-task-master/commit/34c769bcd0faf65ddec3b95de2ba152a8be3ec5c) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Enhance analyze-complexity to support analyzing specific task IDs. - You can now analyze individual tasks or selected task groups by using the new `--id` option with comma-separated IDs, or `--from` and `--to` options to specify a range of tasks. - The feature intelligently merges analysis results with existing reports, allowing incremental analysis while preserving previous results.
+
+- [#558](https://github.com/eyaltoledano/claude-task-master/pull/558) [`86d8f00`](https://github.com/eyaltoledano/claude-task-master/commit/86d8f00af809887ee0ba0ba7157cc555e0d07c38) Thanks [@ShreyPaharia](https://github.com/ShreyPaharia)! - Add next task to set task status response
+  Status: DONE
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`04af16d`](https://github.com/eyaltoledano/claude-task-master/commit/04af16de27295452e134b17b3c7d0f44bbb84c29) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add move command to enable moving tasks and subtasks within the task hierarchy. This new command supports moving standalone tasks to become subtasks, subtasks to become standalone tasks, and moving subtasks between different parents. The implementation handles circular dependencies, validation, and proper updating of parent-child relationships.
+
+  **Usage:**
+
+  - CLI command: `task-master move --from=<id> --to=<id>`
+  - MCP tool: `move_task` with parameters:
+    - `from`: ID of task/subtask to move (e.g., "5" or "5.2")
+    - `to`: ID of destination (e.g., "7" or "7.3")
+    - `file` (optional): Custom path to tasks.json
+
+  **Example scenarios:**
+
+  - Move task to become subtask: `--from="5" --to="7"`
+  - Move subtask to standalone task: `--from="5.2" --to="7"`
+  - Move subtask to different parent: `--from="5.2" --to="7.3"`
+  - Reorder subtask within same parent: `--from="5.2" --to="5.4"`
+  - Move multiple tasks at once: `--from="10,11,12" --to="16,17,18"`
+  - Move task to new ID: `--from="5" --to="25"` (creates a new task with ID 25)
+
+  **Multiple Task Support:**
+  The command supports moving multiple tasks simultaneously by providing comma-separated lists for both `--from` and `--to` parameters. The number of source and destination IDs must match. This is particularly useful for resolving merge conflicts in task files when multiple team members have created tasks on different branches.
+
+  **Validation Features:**
+
+  - Allows moving tasks to new, non-existent IDs (automatically creates placeholders)
+  - Prevents moving to existing task IDs that already contain content (to avoid overwriting)
+  - Validates source tasks exist before attempting to move them
+  - Ensures proper parent-child relationships are maintained
+
+### Patch Changes
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`231e569`](https://github.com/eyaltoledano/claude-task-master/commit/231e569e84804a2e5ba1f9da1a985d0851b7e949) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adjusts default main model model to Claude Sonnet 4. Adjusts default fallback to Claude Sonney 3.7"
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`b371808`](https://github.com/eyaltoledano/claude-task-master/commit/b371808524f2c2986f4940d78fcef32c125d01f2) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds llms-install.md to the root to enable AI agents to programmatically install the Taskmaster MCP server. This is specifically being introduced for the Cline MCP marketplace and will be adjusted over time for other MCP clients as needed.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`a59dd03`](https://github.com/eyaltoledano/claude-task-master/commit/a59dd037cfebb46d38bc44dd216c7c23933be641) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds AGENTS.md to power Claude Code integration more natively based on Anthropic's best practice and Claude-specific MCP client behaviours. Also adds in advanced workflows that tie Taskmaster commands together into one Claude workflow."
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`e0e1155`](https://github.com/eyaltoledano/claude-task-master/commit/e0e115526089bf41d5d60929956edf5601ff3e23) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes issue with force/append flag combinations for parse-prd.
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34df2c8`](https://github.com/eyaltoledano/claude-task-master/commit/34df2c8bbddc0e157c981d32502bbe6b9468202e) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - You can now add tasks to a newly initialized project without having to parse a prd. This will automatically create the missing tasks.json file and create the first task. Lets you vibe if you want to vibe."
+
+- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`d2e6431`](https://github.com/eyaltoledano/claude-task-master/commit/d2e64318e2f4bfc3457792e310cc4ff9210bba30) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue where the research fallback would attempt to make API calls without checking for a valid API key first. This ensures proper error handling when the main task generation and first fallback both fail. Closes #421 #519.
+
+## 0.14.0
+
+### Minor Changes
+
+- [#521](https://github.com/eyaltoledano/claude-task-master/pull/521) [`ed17cb0`](https://github.com/eyaltoledano/claude-task-master/commit/ed17cb0e0a04dedde6c616f68f24f3660f68dd04) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - .taskmasterconfig now supports a baseUrl field per model role (main, research, fallback), allowing endpoint overrides for any provider.
+
+- [#536](https://github.com/eyaltoledano/claude-task-master/pull/536) [`f4a83ec`](https://github.com/eyaltoledano/claude-task-master/commit/f4a83ec047b057196833e3a9b861d4bceaec805d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Ollama as a supported AI provider.
+
+  - You can now add it by running `task-master models --setup` and selecting it.
+  - Ollama is a local model provider, so no API key is required.
+  - Ollama models are available at `http://localhost:11434/api` by default.
+  - You can change the default URL by setting the `OLLAMA_BASE_URL` environment variable or by adding a `baseUrl` property to the `ollama` model role in `.taskmasterconfig`.
+    - If you want to use a custom API key, you can set it in the `OLLAMA_API_KEY` environment variable.
+
+- [#528](https://github.com/eyaltoledano/claude-task-master/pull/528) [`58b417a`](https://github.com/eyaltoledano/claude-task-master/commit/58b417a8ce697e655f749ca4d759b1c20014c523) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Display task complexity scores in task lists, next task, and task details views.
+
+### Patch Changes
+
+- [#402](https://github.com/eyaltoledano/claude-task-master/pull/402) [`01963af`](https://github.com/eyaltoledano/claude-task-master/commit/01963af2cb6f77f43b2ad8a6e4a838ec205412bc) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Resolve all issues related to MCP
+
+- [#478](https://github.com/eyaltoledano/claude-task-master/pull/478) [`4117f71`](https://github.com/eyaltoledano/claude-task-master/commit/4117f71c18ee4d321a9c91308d00d5d69bfac61e) Thanks [@joedanz](https://github.com/joedanz)! - Fix CLI --force flag for parse-prd command
+
+  Previously, the --force flag was not respected when running `parse-prd`, causing the command to prompt for confirmation or fail even when --force was provided. This patch ensures that the flag is correctly passed and handled, allowing users to overwrite existing tasks.json files as intended.
+
+  - Fixes #477
+
+- [#511](https://github.com/eyaltoledano/claude-task-master/pull/511) [`17294ff`](https://github.com/eyaltoledano/claude-task-master/commit/17294ff25918d64278674e558698a1a9ad785098) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Task Master no longer tells you to update when you're already up to date
+
+- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`2b3ae8b`](https://github.com/eyaltoledano/claude-task-master/commit/2b3ae8bf89dc471c4ce92f3a12ded57f61faa449) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds costs information to AI commands using input/output tokens and model costs.
+
+- [#402](https://github.com/eyaltoledano/claude-task-master/pull/402) [`01963af`](https://github.com/eyaltoledano/claude-task-master/commit/01963af2cb6f77f43b2ad8a6e4a838ec205412bc) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix ERR_MODULE_NOT_FOUND when trying to run MCP Server
+
+- [#402](https://github.com/eyaltoledano/claude-task-master/pull/402) [`01963af`](https://github.com/eyaltoledano/claude-task-master/commit/01963af2cb6f77f43b2ad8a6e4a838ec205412bc) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add src directory to exports
+
+- [#523](https://github.com/eyaltoledano/claude-task-master/pull/523) [`da317f2`](https://github.com/eyaltoledano/claude-task-master/commit/da317f2607ca34db1be78c19954996f634c40923) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix the error handling of task status settings
+
+- [#527](https://github.com/eyaltoledano/claude-task-master/pull/527) [`a8dabf4`](https://github.com/eyaltoledano/claude-task-master/commit/a8dabf44856713f488960224ee838761716bba26) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Remove caching layer from MCP direct functions for task listing, next task, and complexity report
+
+  - Fixes issues users where having where they were getting stale data
+
+- [#417](https://github.com/eyaltoledano/claude-task-master/pull/417) [`a1f8d52`](https://github.com/eyaltoledano/claude-task-master/commit/a1f8d52474fdbdf48e17a63e3f567a6d63010d9f) Thanks [@ksylvan](https://github.com/ksylvan)! - Fix for issue #409 LOG_LEVEL Pydantic validation error
+
+- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`0288311`](https://github.com/eyaltoledano/claude-task-master/commit/0288311965ae2a343ebee4a0c710dde94d2ae7e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Small fixes - `next` command no longer incorrectly suggests that subtasks be broken down into subtasks in the CLI - fixes the `append` flag so it properly works in the CLI
+
+- [#501](https://github.com/eyaltoledano/claude-task-master/pull/501) [`0a61184`](https://github.com/eyaltoledano/claude-task-master/commit/0a611843b56a856ef0a479dc34078326e05ac3a8) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix initial .env.example to work out of the box
+
+  - Closes #419
+
+- [#435](https://github.com/eyaltoledano/claude-task-master/pull/435) [`a96215a`](https://github.com/eyaltoledano/claude-task-master/commit/a96215a359b25061fd3b3f3c7b10e8ac0390c062) Thanks [@lebsral](https://github.com/lebsral)! - Fix default fallback model and maxTokens in Taskmaster initialization
+
+- [#517](https://github.com/eyaltoledano/claude-task-master/pull/517) [`e96734a`](https://github.com/eyaltoledano/claude-task-master/commit/e96734a6cc6fec7731de72eb46b182a6e3743d02) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix bug when updating tasks on the MCP server (#412)
+
+- [#496](https://github.com/eyaltoledano/claude-task-master/pull/496) [`efce374`](https://github.com/eyaltoledano/claude-task-master/commit/efce37469bc58eceef46763ba32df1ed45242211) Thanks [@joedanz](https://github.com/joedanz)! - Fix duplicate output on CLI help screen
+
+  - Prevent the Task Master CLI from printing the help screen more than once when using `-h` or `--help`.
+  - Removed redundant manual event handlers and guards for help output; now only the Commander `.helpInformation` override is used for custom help.
+  - Simplified logic so that help is only shown once for both "no arguments" and help flag flows.
+  - Ensures a clean, branded help experience with no repeated content.
+  - Fixes #339
+
+## 0.14.0-rc.1
+
+### Minor Changes
+
+- [#536](https://github.com/eyaltoledano/claude-task-master/pull/536) [`f4a83ec`](https://github.com/eyaltoledano/claude-task-master/commit/f4a83ec047b057196833e3a9b861d4bceaec805d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Ollama as a supported AI provider.
+
+  - You can now add it by running `task-master models --setup` and selecting it.
+  - Ollama is a local model provider, so no API key is required.
+  - Ollama models are available at `http://localhost:11434/api` by default.
+  - You can change the default URL by setting the `OLLAMA_BASE_URL` environment variable or by adding a `baseUrl` property to the `ollama` model role in `.taskmasterconfig`.
+    - If you want to use a custom API key, you can set it in the `OLLAMA_API_KEY` environment variable.
+
+### Patch Changes
+
+- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`2b3ae8b`](https://github.com/eyaltoledano/claude-task-master/commit/2b3ae8bf89dc471c4ce92f3a12ded57f61faa449) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds costs information to AI commands using input/output tokens and model costs.
+
+- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`0288311`](https://github.com/eyaltoledano/claude-task-master/commit/0288311965ae2a343ebee4a0c710dde94d2ae7e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Small fixes - `next` command no longer incorrectly suggests that subtasks be broken down into subtasks in the CLI - fixes the `append` flag so it properly works in the CLI
+
+## 0.14.0-rc.0
+
+### Minor Changes
+
+- [#521](https://github.com/eyaltoledano/claude-task-master/pull/521) [`ed17cb0`](https://github.com/eyaltoledano/claude-task-master/commit/ed17cb0e0a04dedde6c616f68f24f3660f68dd04) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - .taskmasterconfig now supports a baseUrl field per model role (main, research, fallback), allowing endpoint overrides for any provider.
+
+- [#528](https://github.com/eyaltoledano/claude-task-master/pull/528) [`58b417a`](https://github.com/eyaltoledano/claude-task-master/commit/58b417a8ce697e655f749ca4d759b1c20014c523) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Display task complexity scores in task lists, next task, and task details views.
+
+### Patch Changes
+
+- [#478](https://github.com/eyaltoledano/claude-task-master/pull/478) [`4117f71`](https://github.com/eyaltoledano/claude-task-master/commit/4117f71c18ee4d321a9c91308d00d5d69bfac61e) Thanks [@joedanz](https://github.com/joedanz)! - Fix CLI --force flag for parse-prd command
+
+  Previously, the --force flag was not respected when running `parse-prd`, causing the command to prompt for confirmation or fail even when --force was provided. This patch ensures that the flag is correctly passed and handled, allowing users to overwrite existing tasks.json files as intended.
+
+  - Fixes #477
+
+- [#511](https://github.com/eyaltoledano/claude-task-master/pull/511) [`17294ff`](https://github.com/eyaltoledano/claude-task-master/commit/17294ff25918d64278674e558698a1a9ad785098) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Task Master no longer tells you to update when you're already up to date
+
+- [#523](https://github.com/eyaltoledano/claude-task-master/pull/523) [`da317f2`](https://github.com/eyaltoledano/claude-task-master/commit/da317f2607ca34db1be78c19954996f634c40923) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix the error handling of task status settings
+
+- [#527](https://github.com/eyaltoledano/claude-task-master/pull/527) [`a8dabf4`](https://github.com/eyaltoledano/claude-task-master/commit/a8dabf44856713f488960224ee838761716bba26) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Remove caching layer from MCP direct functions for task listing, next task, and complexity report
+
+  - Fixes issues users where having where they were getting stale data
+
+- [#417](https://github.com/eyaltoledano/claude-task-master/pull/417) [`a1f8d52`](https://github.com/eyaltoledano/claude-task-master/commit/a1f8d52474fdbdf48e17a63e3f567a6d63010d9f) Thanks [@ksylvan](https://github.com/ksylvan)! - Fix for issue #409 LOG_LEVEL Pydantic validation error
+
+- [#501](https://github.com/eyaltoledano/claude-task-master/pull/501) [`0a61184`](https://github.com/eyaltoledano/claude-task-master/commit/0a611843b56a856ef0a479dc34078326e05ac3a8) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix initial .env.example to work out of the box
+
+  - Closes #419
+
+- [#435](https://github.com/eyaltoledano/claude-task-master/pull/435) [`a96215a`](https://github.com/eyaltoledano/claude-task-master/commit/a96215a359b25061fd3b3f3c7b10e8ac0390c062) Thanks [@lebsral](https://github.com/lebsral)! - Fix default fallback model and maxTokens in Taskmaster initialization
+
+- [#517](https://github.com/eyaltoledano/claude-task-master/pull/517) [`e96734a`](https://github.com/eyaltoledano/claude-task-master/commit/e96734a6cc6fec7731de72eb46b182a6e3743d02) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix bug when updating tasks on the MCP server (#412)
+
+- [#496](https://github.com/eyaltoledano/claude-task-master/pull/496) [`efce374`](https://github.com/eyaltoledano/claude-task-master/commit/efce37469bc58eceef46763ba32df1ed45242211) Thanks [@joedanz](https://github.com/joedanz)! - Fix duplicate output on CLI help screen
+
+  - Prevent the Task Master CLI from printing the help screen more than once when using `-h` or `--help`.
+  - Removed redundant manual event handlers and guards for help output; now only the Commander `.helpInformation` override is used for custom help.
+  - Simplified logic so that help is only shown once for both "no arguments" and help flag flows.
+  - Ensures a clean, branded help experience with no repeated content.
+  - Fixes #339
+
 ## 0.13.1
 
 ### Patch Changes

CONTRIBUTING.md

@@ -0,0 +1,335 @@
+# Contributing to Task Master
+
+Thank you for your interest in contributing to Task Master! We're excited to work with you and appreciate your help in making this project better. 🚀
+
+## 🤝 Our Collaborative Approach
+
+We're a **PR-friendly team** that values collaboration:
+
+- ✅ **We review PRs quickly** - Usually within hours, not days
+- ✅ **We're super reactive** - Expect fast feedback and engagement
+- ✅ **We sometimes take over PRs** - If your contribution is valuable but needs cleanup, we might jump in to help finish it
+- ✅ **We're open to all contributions** - From bug fixes to major features
+
+**We don't mind AI-generated code**, but we do expect you to:
+
+- ✅ **Review and understand** what the AI generated
+- ✅ **Test the code thoroughly** before submitting
+- ✅ **Ensure it's well-written** and follows our patterns
+- ❌ **Don't submit "AI slop"** - untested, unreviewed AI output
+
+> **Why this matters**: We spend significant time reviewing PRs. Help us help you by submitting quality contributions that save everyone time!
+
+## 🚀 Quick Start for Contributors
+
+### 1. Fork and Clone
+
+```bash
+git clone https://github.com/YOUR_USERNAME/claude-task-master.git
+cd claude-task-master
+npm install
+```
+
+### 2. Create a Feature Branch
+
+**Important**: Always target the `next` branch, not `main`:
+
+```bash
+git checkout next
+git pull origin next
+git checkout -b feature/your-feature-name
+```
+
+### 3. Make Your Changes
+
+Follow our development guidelines below.
+
+### 4. Test Everything Yourself
+
+**Before submitting your PR**, ensure:
+
+```bash
+# Run all tests
+npm test
+
+# Check formatting
+npm run format-check
+
+# Fix formatting if needed
+npm run format
+```
+
+### 5. Create a Changeset
+
+**Required for most changes**:
+
+```bash
+npm run changeset
+```
+
+See the [Changeset Guidelines](#changeset-guidelines) below for details.
+
+### 6. Submit Your PR
+
+- Target the `next` branch
+- Write a clear description
+- Reference any related issues
+
+## 📋 Development Guidelines
+
+### Branch Strategy
+
+- **`main`**: Production-ready code
+- **`next`**: Development branch - **target this for PRs**
+- **Feature branches**: `feature/description` or `fix/description`
+
+### Code Quality Standards
+
+1. **Write tests** for new functionality
+2. **Follow existing patterns** in the codebase
+3. **Add JSDoc comments** for functions
+4. **Keep functions focused** and single-purpose
+
+### Testing Requirements
+
+Your PR **must pass all CI checks**:
+
+- ✅ **Unit tests**: `npm test`
+- ✅ **Format check**: `npm run format-check`
+
+**Test your changes locally first** - this saves review time and shows you care about quality.
+
+## 📦 Changeset Guidelines
+
+We use [Changesets](https://github.com/changesets/changesets) to manage versioning and generate changelogs.
+
+### When to Create a Changeset
+
+**Always create a changeset for**:
+
+- ✅ New features
+- ✅ Bug fixes
+- ✅ Breaking changes
+- ✅ Performance improvements
+- ✅ User-facing documentation updates
+- ✅ Dependency updates that affect functionality
+
+**Skip changesets for**:
+
+- ❌ Internal documentation only
+- ❌ Test-only changes
+- ❌ Code formatting/linting
+- ❌ Development tooling that doesn't affect users
+
+### How to Create a Changeset
+
+1. **After making your changes**:
+
+   ```bash
+   npm run changeset
+   ```
+
+2. **Choose the bump type**:
+
+   - **Major**: Breaking changes
+   - **Minor**: New features
+   - **Patch**: Bug fixes, docs, performance improvements
+
+3. **Write a clear summary**:
+
+   ```
+   Add support for custom AI models in MCP configuration
+   ```
+
+4. **Commit the changeset file** with your changes:
+   ```bash
+   git add .changeset/*.md
+   git commit -m "feat: add custom AI model support"
+   ```
+
+### Changeset vs Git Commit Messages
+
+- **Changeset summary**: User-facing, goes in CHANGELOG.md
+- **Git commit**: Developer-facing, explains the technical change
+
+Example:
+
+```bash
+# Changeset summary (user-facing)
+"Add support for custom Ollama models"
+
+# Git commit message (developer-facing)
+"feat(models): implement custom Ollama model validation
+
+- Add model validation for custom Ollama endpoints
+- Update configuration schema to support custom models
+- Add tests for new validation logic"
+```
+
+## 🔧 Development Setup
+
+### Prerequisites
+
+- Node.js 14+
+- npm or yarn
+
+### Environment Setup
+
+1. **Copy environment template**:
+
+   ```bash
+   cp .env.example .env
+   ```
+
+2. **Add your API keys** (for testing AI features):
+   ```bash
+   ANTHROPIC_API_KEY=your_key_here
+   OPENAI_API_KEY=your_key_here
+   # Add others as needed
+   ```
+
+### Running Tests
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run with coverage
+npm run test:coverage
+
+# Run E2E tests
+npm run test:e2e
+```
+
+### Code Formatting
+
+We use Prettier for consistent formatting:
+
+```bash
+# Check formatting
+npm run format-check
+
+# Fix formatting
+npm run format
+```
+
+## 📝 PR Guidelines
+
+### Before Submitting
+
+- [ ] **Target the `next` branch**
+- [ ] **Test everything locally**
+- [ ] **Run the full test suite**
+- [ ] **Check code formatting**
+- [ ] **Create a changeset** (if needed)
+- [ ] **Re-read your changes** - ensure they're clean and well-thought-out
+
+### PR Description Template
+
+```markdown
+## Description
+
+Brief description of what this PR does.
+
+## Type of Change
+
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Breaking change
+- [ ] Documentation update
+
+## Testing
+
+- [ ] I have tested this locally
+- [ ] All existing tests pass
+- [ ] I have added tests for new functionality
+
+## Changeset
+
+- [ ] I have created a changeset (or this change doesn't need one)
+
+## Additional Notes
+
+Any additional context or notes for reviewers.
+```
+
+### What We Look For
+
+✅ **Good PRs**:
+
+- Clear, focused changes
+- Comprehensive testing
+- Good commit messages
+- Proper changeset (when needed)
+- Self-reviewed code
+
+❌ **Avoid**:
+
+- Massive PRs that change everything
+- Untested code
+- Formatting issues
+- Missing changesets for user-facing changes
+- AI-generated code that wasn't reviewed
+
+## 🏗️ Project Structure
+
+```
+claude-task-master/
+├── bin/                    # CLI executables
+├── mcp-server/            # MCP server implementation
+├── scripts/               # Core task management logic
+├── src/                   # Shared utilities and providers and well refactored code (we are slowly moving everything here)
+├── tests/                 # Test files
+├── docs/                  # Documentation
+└── .cursor/               # Cursor IDE rules and configuration
+└── assets/							   # Assets like rules and configuration for all IDEs
+```
+
+### Key Areas for Contribution
+
+- **CLI Commands**: `scripts/modules/commands.js`
+- **MCP Tools**: `mcp-server/src/tools/`
+- **Core Logic**: `scripts/modules/task-manager/`
+- **AI Providers**: `src/ai-providers/`
+- **Tests**: `tests/`
+
+## 🐛 Reporting Issues
+
+### Bug Reports
+
+Include:
+
+- Task Master version
+- Node.js version
+- Operating system
+- Steps to reproduce
+- Expected vs actual behavior
+- Error messages/logs
+
+### Feature Requests
+
+Include:
+
+- Clear description of the feature
+- Use case/motivation
+- Proposed implementation (if you have ideas)
+- Willingness to contribute
+
+## 💬 Getting Help
+
+- **Discord**: [Join our community](https://discord.gg/taskmasterai)
+- **Issues**: [GitHub Issues](https://github.com/eyaltoledano/claude-task-master/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/eyaltoledano/claude-task-master/discussions)
+
+## 📄 License
+
+By contributing, you agree that your contributions will be licensed under the same license as the project (MIT with Commons Clause).
+
+---
+
+**Thank you for contributing to Task Master!** 🎉
+
+Your contributions help make AI-driven development more accessible and efficient for everyone.

README.md

@@ -11,18 +11,39 @@ A task management system for AI-driven development with Claude, designed to work
 
 ## Requirements
 
+Taskmaster utilizes AI across several commands, and those require a separate API key. You can use a variety of models from different AI providers provided you add your API keys. For example, if you want to use Claude 3.7, you'll need an Anthropic API key.
+
+You can define 3 types of models to be used: the main model, the research model, and the fallback model (in case either the main or research fail). Whatever model you use, its provider API key must be present in either mcp.json or .env.
+
+At least one (1) of the following is required:
+
 - Anthropic API key (Claude API)
-- OpenAI SDK (for Perplexity API integration, optional)
+- OpenAI API key
+- Google Gemini API key
+- Perplexity API key (for research model)
+- xAI API Key (for research or main model)
+- OpenRouter API Key (for research or main model)
+
+Using the research model is optional but highly recommended. You will need at least ONE API key. Adding all API keys enables you to seamlessly switch between model providers at will.
 
 ## Quick Start
 
-### Option 1 | MCP (Recommended):
+### Option 1: MCP (Recommended)
 
-MCP (Model Control Protocol) provides the easiest way to get started with Task Master directly in your editor.
+MCP (Model Control Protocol) lets you run Task Master directly from your editor.
 
-1. **Add the MCP config to your editor** (Cursor recommended, but it works with other text editors):
+#### 1. Add your MCP config at the following path depending on your editor
 
-```json
+| Editor       | Scope   | Linux/macOS Path                      | Windows Path                                      | Key          |
+| ------------ | ------- | ------------------------------------- | ------------------------------------------------- | ------------ |
+| **Cursor**   | Global  | `~/.cursor/mcp.json`                  | `%USERPROFILE%\.cursor\mcp.json`                  | `mcpServers` |
+|              | Project | `<project_folder>/.cursor/mcp.json`   | `<project_folder>\.cursor\mcp.json`               | `mcpServers` |
+| **Windsurf** | Global  | `~/.codeium/windsurf/mcp_config.json` | `%USERPROFILE%\.codeium\windsurf\mcp_config.json` | `mcpServers` |
+| **VS Code**  | Project | `<project_folder>/.vscode/mcp.json`   | `<project_folder>\.vscode\mcp.json`               | `servers`    |
+
+##### Cursor & Windsurf (`mcpServers`)
+
+```jsonc
 {
 	"mcpServers": {
 		"taskmaster-ai": {
@@ -36,30 +57,83 @@ MCP (Model Control Protocol) provides the easiest way to get started with Task M
 				"MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
 				"OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
 				"XAI_API_KEY": "YOUR_XAI_KEY_HERE",
-				"AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE"
+				"AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE",
+				"OLLAMA_API_KEY": "YOUR_OLLAMA_API_KEY_HERE"
 			}
 		}
 	}
 }
 ```
 
-2. **Enable the MCP** in your editor
+> 🔑 Replace `YOUR_…_KEY_HERE` with your real API keys. You can remove keys you don't use.
 
-3. **Prompt the AI** to initialize Task Master:
+##### VS Code (`servers` + `type`)
 
-```
+```jsonc
-Can you please initialize taskmaster-ai into my project?
+{
+	"servers": {
+		"taskmaster-ai": {
+			"command": "npx",
+			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
+			"env": {
+				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
+				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
+				"OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
+				"GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
+				"MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
+				"OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
+				"XAI_API_KEY": "YOUR_XAI_KEY_HERE",
+				"AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE"
+			},
+			"type": "stdio"
+		}
+	}
+}
 ```
 
-4. **Use common commands** directly through your AI assistant:
+> 🔑 Replace `YOUR_…_KEY_HERE` with your real API keys. You can remove keys you don't use.
+
+#### 2. (Cursor-only) Enable Taskmaster MCP
+
+Open Cursor Settings (Ctrl+Shift+J) ➡ Click on MCP tab on the left ➡ Enable task-master-ai with the toggle
+
+#### 3. (Optional) Configure the models you want to use
+
+In your editor’s AI chat pane, say:
 
 ```txt
-Can you parse my PRD at scripts/prd.txt?
+Change the main, research and fallback models to <model_name>, <model_name> and <model_name> respectively.
-What's the next task I should work on?
-Can you help me implement task 3?
-Can you help me expand task 4?
 ```
 
+[Table of available models](docs/models.md)
+
+#### 4. Initialize Task Master
+
+In your editor’s AI chat pane, say:
+
+```txt
+Initialize taskmaster-ai in my project
+```
+
+#### 5. Make sure you have a PRD in `<project_folder>/scripts/prd.txt`
+
+An example of a PRD is located into `<project_folder>/scripts/example_prd.txt`.
+
+**Always start with a detailed PRD.**
+
+The more detailed your PRD, the better the generated tasks will be.
+
+#### 6. Common Commands
+
+Use your AI assistant to:
+
+- Parse requirements: `Can you parse my PRD at scripts/prd.txt?`
+- Plan next step: `What’s the next task I should work on?`
+- Implement a task: `Can you help me implement task 3?`
+- Expand a task: `Can you help me expand task 4?`
+
+[More examples on how to use Task Master in chat](docs/examples.md)
+
 ### Option 2: Using Command Line
 
 #### Installation

assets/.taskmasterconfig

@@ -25,7 +25,7 @@
 		"defaultSubtasks": 5,
 		"defaultPriority": "medium",
 		"projectName": "Taskmaster",
-		"ollamaBaseUrl": "http://localhost:11434/api",
+		"ollamaBaseURL": "http://localhost:11434/api",
-		"azureOpenaiBaseUrl": "https://your-endpoint.openai.azure.com/"
+		"azureOpenaiBaseURL": "https://your-endpoint.openai.azure.com/"
 	}
 }

assets/AGENTS.md

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

assets/env.example

@@ -5,4 +5,5 @@ OPENAI_API_KEY="your_openai_api_key_here"             # Optional, for OpenAI/Ope
 GOOGLE_API_KEY="your_google_api_key_here"             # Optional, for Google Gemini models.
 MISTRAL_API_KEY="your_mistral_key_here"               # Optional, for Mistral AI models.
 XAI_API_KEY="YOUR_XAI_KEY_HERE"                       # Optional, for xAI AI models.
-AZURE_OPENAI_API_KEY="your_azure_key_here"            # Optional, for Azure OpenAI models (requires endpoint in .taskmasterconfig).
+AZURE_OPENAI_API_KEY="your_azure_key_here"            # Optional, for Azure OpenAI models (requires endpoint in .taskmasterconfig).
+OLLAMA_API_KEY="your_ollama_api_key_here"             # Optional: For remote Ollama servers that require authentication.

assets/roocode/.roomodes

@@ -39,7 +39,7 @@
     {
       "slug": "debug",
       "name": "Debug",
-      "roleDefinition": "You are Roo, an expert software debugger specializing in systematic problem diagnosis and resolution. When activated by another mdode, your task is to meticulously analyze the provided debugging request (potentially referencing Taskmaster tasks, logs, or metrics), use diagnostic tools as instructed to investigate the issue, identify the root cause, and report your findings and recommended next steps back via `attempt_completion`. You focus solely on diagnostics within the scope defined by the delegated task.",
+      "roleDefinition": "You are Roo, an expert software debugger specializing in systematic problem diagnosis and resolution. When activated by another mode, your task is to meticulously analyze the provided debugging request (potentially referencing Taskmaster tasks, logs, or metrics), use diagnostic tools as instructed to investigate the issue, identify the root cause, and report your findings and recommended next steps back via `attempt_completion`. You focus solely on diagnostics within the scope defined by the delegated task.",
       "customInstructions": "Reflect on 5-7 different possible sources of the problem, distill those down to 1-2 most likely sources, and then add logs to validate your assumptions. Explicitly ask the user to confirm the diagnosis before fixing the problem.",
       "groups": [
         "read",

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

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

docs/command-reference.md

@@ -187,6 +187,32 @@ task-master validate-dependencies
 task-master fix-dependencies
 ```
 
+## Move Tasks
+
+```bash
+# Move a task or subtask to a new position
+task-master move --from=<id> --to=<id>
+
+# Examples:
+# Move task to become a subtask
+task-master move --from=5 --to=7
+
+# Move subtask to become a standalone task
+task-master move --from=5.2 --to=7
+
+# Move subtask to a different parent
+task-master move --from=5.2 --to=7.3
+
+# Reorder subtasks within the same parent
+task-master move --from=5.2 --to=5.4
+
+# Move a task to a new ID position (creates placeholder if doesn't exist)
+task-master move --from=5 --to=25
+
+# Move multiple tasks at once (must have the same number of IDs)
+task-master move --from=10,11,12 --to=16,17,18
+```
+
 ## Add a New Task
 
 ```bash

docs/configuration.md

@@ -16,14 +16,14 @@ Taskmaster uses two primary methods for configuration:
       			"modelId": "claude-3-7-sonnet-20250219",
       			"maxTokens": 64000,
       			"temperature": 0.2,
-      			"baseUrl": "https://api.anthropic.com/v1"
+      			"baseURL": "https://api.anthropic.com/v1"
       		},
       		"research": {
       			"provider": "perplexity",
       			"modelId": "sonar-pro",
       			"maxTokens": 8700,
       			"temperature": 0.1,
-      			"baseUrl": "https://api.perplexity.ai/v1"
+      			"baseURL": "https://api.perplexity.ai/v1"
       		},
       		"fallback": {
       			"provider": "anthropic",
@@ -38,8 +38,10 @@ Taskmaster uses two primary methods for configuration:
       		"defaultSubtasks": 5,
       		"defaultPriority": "medium",
       		"projectName": "Your Project Name",
-      		"ollamaBaseUrl": "http://localhost:11434/api",
+      		"ollamaBaseURL": "http://localhost:11434/api",
-      		"azureOpenaiBaseUrl": "https://your-endpoint.openai.azure.com/"
+      		"azureBaseURL": "https://your-endpoint.azure.com/",
+      		"vertexProjectId": "your-gcp-project-id",
+      		"vertexLocation": "us-central1"
       	}
       }
       ```
@@ -53,15 +55,18 @@ Taskmaster uses two primary methods for configuration:
       - `ANTHROPIC_API_KEY`: Your Anthropic API key.
       - `PERPLEXITY_API_KEY`: Your Perplexity API key.
       - `OPENAI_API_KEY`: Your OpenAI API key.
-      - `GOOGLE_API_KEY`: Your Google API key.
+      - `GOOGLE_API_KEY`: Your Google API key (also used for Vertex AI provider).
       - `MISTRAL_API_KEY`: Your Mistral API key.
       - `AZURE_OPENAI_API_KEY`: Your Azure OpenAI API key (also requires `AZURE_OPENAI_ENDPOINT`).
       - `OPENROUTER_API_KEY`: Your OpenRouter API key.
       - `XAI_API_KEY`: Your X-AI API key.
     - **Optional Endpoint Overrides:**
-      - **Per-role `baseUrl` in `.taskmasterconfig`:** You can add a `baseUrl` property to any model role (`main`, `research`, `fallback`) to override the default API endpoint for that provider. If omitted, the provider's standard endpoint is used.
+      - **Per-role `baseURL` in `.taskmasterconfig`:** You can add a `baseURL` property to any model role (`main`, `research`, `fallback`) to override the default API endpoint for that provider. If omitted, the provider's standard endpoint is used.
-      - `AZURE_OPENAI_ENDPOINT`: Required if using Azure OpenAI key (can also be set as `baseUrl` for the Azure model role).
+      - `AZURE_OPENAI_ENDPOINT`: Required if using Azure OpenAI key (can also be set as `baseURL` for the Azure model role).
       - `OLLAMA_BASE_URL`: Override the default Ollama API URL (Default: `http://localhost:11434/api`).
+      - `VERTEX_PROJECT_ID`: Your Google Cloud project ID for Vertex AI. Required when using the 'vertex' provider.
+      - `VERTEX_LOCATION`: Google Cloud region for Vertex AI (e.g., 'us-central1'). Default is 'us-central1'.
+      - `GOOGLE_APPLICATION_CREDENTIALS`: Path to service account credentials JSON file for Google Cloud auth (alternative to API key for Vertex AI).
 
 **Important:** Settings like model ID selections (`main`, `research`, `fallback`), `maxTokens`, `temperature`, `logLevel`, `defaultSubtasks`, `defaultPriority`, and `projectName` are **managed in `.taskmasterconfig`**, not environment variables.
 
@@ -78,6 +83,11 @@ PERPLEXITY_API_KEY=pplx-your-key-here
 # Optional Endpoint Overrides
 # AZURE_OPENAI_ENDPOINT=https://your-azure-endpoint.openai.azure.com/
 # OLLAMA_BASE_URL=http://custom-ollama-host:11434/api
+
+# Google Vertex AI Configuration (Required if using 'vertex' provider)
+# VERTEX_PROJECT_ID=your-gcp-project-id
+# VERTEX_LOCATION=us-central1
+# GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-credentials.json
 ```
 
 ## Troubleshooting
@@ -102,3 +112,45 @@ git clone https://github.com/eyaltoledano/claude-task-master.git
 cd claude-task-master
 node scripts/init.js
 ```
+
+## Provider-Specific Configuration
+
+### Google Vertex AI Configuration
+
+Google Vertex AI is Google Cloud's enterprise AI platform and requires specific configuration:
+
+1. **Prerequisites**:
+   - A Google Cloud account with Vertex AI API enabled
+   - Either a Google API key with Vertex AI permissions OR a service account with appropriate roles
+   - A Google Cloud project ID
+2. **Authentication Options**:
+   - **API Key**: Set the `GOOGLE_API_KEY` environment variable
+   - **Service Account**: Set `GOOGLE_APPLICATION_CREDENTIALS` to point to your service account JSON file
+3. **Required Configuration**:
+   - Set `VERTEX_PROJECT_ID` to your Google Cloud project ID
+   - Set `VERTEX_LOCATION` to your preferred Google Cloud region (default: us-central1)
+4. **Example Setup**:
+
+   ```bash
+   # In .env file
+   GOOGLE_API_KEY=AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXX
+   VERTEX_PROJECT_ID=my-gcp-project-123
+   VERTEX_LOCATION=us-central1
+   ```
+
+   Or using service account:
+
+   ```bash
+   # In .env file
+   GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
+   VERTEX_PROJECT_ID=my-gcp-project-123
+   VERTEX_LOCATION=us-central1
+   ```
+
+5. **In .taskmasterconfig**:
+   ```json
+   "global": {
+     "vertexProjectId": "my-gcp-project-123",
+     "vertexLocation": "us-central1"
+   }
+   ```

docs/examples.md

@@ -30,7 +30,7 @@ I need to regenerate the subtasks for task 3 with a different approach. Can you
 ## Handling changes
 
 ```
-We've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks to reflect this change?
+I've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks to reflect this change?
 ```
 
 ## Completing work
@@ -40,6 +40,34 @@ I've finished implementing the authentication system described in task 2. All te
 Please mark it as complete and tell me what I should work on next.
 ```
 
+## Reorganizing tasks
+
+```
+I think subtask 5.2 would fit better as part of task 7. Can you move it there?
+```
+
+(Agent runs: `task-master move --from=5.2 --to=7.3`)
+
+```
+Task 8 should actually be a subtask of task 4. Can you reorganize this?
+```
+
+(Agent runs: `task-master move --from=8 --to=4.1`)
+
+```
+I just merged the main branch and there's a conflict in tasks.json. My teammates created tasks 10-15 on their branch while I created tasks 10-12 on my branch. Can you help me resolve this by moving my tasks?
+```
+
+(Agent runs:
+
+```bash
+task-master move --from=10 --to=16
+task-master move --from=11 --to=17
+task-master move --from=12 --to=18
+```
+
+)
+
 ## Analyzing complexity
 
 ```

docs/models.md

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

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

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

docs/tutorial.md

@@ -268,7 +268,61 @@ task-master update --from=4 --prompt="Update to use MongoDB, researching best pr
 
 This will rewrite or re-scope subsequent tasks in tasks.json while preserving completed work.
 
-### 6. Breaking Down Complex Tasks
+### 6. Reorganizing Tasks
+
+If you need to reorganize your task structure:
+
+```
+I think subtask 5.2 would fit better as part of task 7 instead. Can you move it there?
+```
+
+The agent will execute:
+
+```bash
+task-master move --from=5.2 --to=7.3
+```
+
+You can reorganize tasks in various ways:
+
+- Moving a standalone task to become a subtask: `--from=5 --to=7`
+- Moving a subtask to become a standalone task: `--from=5.2 --to=7`
+- Moving a subtask to a different parent: `--from=5.2 --to=7.3`
+- Reordering subtasks within the same parent: `--from=5.2 --to=5.4`
+- Moving a task to a new ID position: `--from=5 --to=25` (even if task 25 doesn't exist yet)
+- Moving multiple tasks at once: `--from=10,11,12 --to=16,17,18` (must have same number of IDs, Taskmaster will look through each position)
+
+When moving tasks to new IDs:
+
+- The system automatically creates placeholder tasks for non-existent destination IDs
+- This prevents accidental data loss during reorganization
+- Any tasks that depend on moved tasks will have their dependencies updated
+- When moving a parent task, all its subtasks are automatically moved with it and renumbered
+
+This is particularly useful as your project understanding evolves and you need to refine your task structure.
+
+### 7. Resolving Merge Conflicts with Tasks
+
+When working with a team, you might encounter merge conflicts in your tasks.json file if multiple team members create tasks on different branches. The move command makes resolving these conflicts straightforward:
+
+```
+I just merged the main branch and there's a conflict with tasks.json. My teammates created tasks 10-15 while I created tasks 10-12 on my branch. Can you help me resolve this?
+```
+
+The agent will help you:
+
+1. Keep your teammates' tasks (10-15)
+2. Move your tasks to new positions to avoid conflicts:
+
+```bash
+# Move your tasks to new positions (e.g., 16-18)
+task-master move --from=10 --to=16
+task-master move --from=11 --to=17
+task-master move --from=12 --to=18
+```
+
+This approach preserves everyone's work while maintaining a clean task structure, making it much easier to handle task conflicts than trying to manually merge JSON files.
+
+### 8. Breaking Down Complex Tasks
 
 For complex tasks that need more granularity:
 

llms-install.md

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

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

@@ -94,6 +94,7 @@ export async function addTaskDirect(args, log, context = {}) {
 
 		let manualTaskData = null;
 		let newTaskId;
+		let telemetryData;
 
 		if (isManualCreation) {
 			// Create manual task data object
@@ -109,7 +110,7 @@ export async function addTaskDirect(args, log, context = {}) {
 			);
 
 			// Call the addTask function with manual task data
-			newTaskId = await addTask(
+			const result = await addTask(
 				tasksPath,
 				null, // prompt is null for manual creation
 				taskDependencies,
@@ -117,13 +118,17 @@ export async function addTaskDirect(args, log, context = {}) {
 				{
 					session,
 					mcpLog,
-					projectRoot
+					projectRoot,
+					commandName: 'add-task',
+					outputType: 'mcp'
 				},
 				'json', // outputFormat
 				manualTaskData, // Pass the manual task data
 				false, // research flag is false for manual creation
 				projectRoot // Pass projectRoot
 			);
+			newTaskId = result.newTaskId;
+			telemetryData = result.telemetryData;
 		} else {
 			// AI-driven task creation
 			log.info(
@@ -131,7 +136,7 @@ export async function addTaskDirect(args, log, context = {}) {
 			);
 
 			// Call the addTask function, passing the research flag
-			newTaskId = await addTask(
+			const result = await addTask(
 				tasksPath,
 				prompt, // Use the prompt for AI creation
 				taskDependencies,
@@ -139,12 +144,16 @@ export async function addTaskDirect(args, log, context = {}) {
 				{
 					session,
 					mcpLog,
-					projectRoot
+					projectRoot,
+					commandName: 'add-task',
+					outputType: 'mcp'
 				},
 				'json', // outputFormat
 				null, // manualTaskData is null for AI creation
 				research // Pass the research flag
 			);
+			newTaskId = result.newTaskId;
+			telemetryData = result.telemetryData;
 		}
 
 		// Restore normal logging
@@ -154,7 +163,8 @@ export async function addTaskDirect(args, log, context = {}) {
 			success: true,
 			data: {
 				taskId: newTaskId,
-				message: `Successfully added new task #${newTaskId}`
+				message: `Successfully added new task #${newTaskId}`,
+				telemetryData: telemetryData
 			}
 		};
 	} catch (error) {

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

@@ -18,6 +18,9 @@ import { createLogWrapper } from '../../tools/utils.js'; // Import the new utili
  * @param {string} args.outputPath - Explicit absolute path to save the report.
  * @param {string|number} [args.threshold] - Minimum complexity score to recommend expansion (1-10)
  * @param {boolean} [args.research] - Use Perplexity AI for research-backed complexity analysis
+ * @param {string} [args.ids] - Comma-separated list of task IDs to analyze
+ * @param {number} [args.from] - Starting task ID in a range to analyze
+ * @param {number} [args.to] - Ending task ID in a range to analyze
  * @param {string} [args.projectRoot] - Project root path.
  * @param {Object} log - Logger object
  * @param {Object} [context={}] - Context object containing session data
@@ -26,7 +29,16 @@ import { createLogWrapper } from '../../tools/utils.js'; // Import the new utili
  */
 export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 	const { session } = context;
-	const { tasksJsonPath, outputPath, threshold, research, projectRoot } = args;
+	const {
+		tasksJsonPath,
+		outputPath,
+		threshold,
+		research,
+		projectRoot,
+		ids,
+		from,
+		to
+	} = args;
 
 	const logWrapper = createLogWrapper(log);
 
@@ -58,6 +70,14 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 		log.info(`Analyzing task complexity from: ${tasksPath}`);
 		log.info(`Output report will be saved to: ${resolvedOutputPath}`);
 
+		if (ids) {
+			log.info(`Analyzing specific task IDs: ${ids}`);
+		} else if (from || to) {
+			const fromStr = from !== undefined ? from : 'first';
+			const toStr = to !== undefined ? to : 'last';
+			log.info(`Analyzing tasks in range: ${fromStr} to ${toStr}`);
+		}
+
 		if (research) {
 			log.info('Using research role for complexity analysis');
 		}
@@ -68,7 +88,10 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 			output: outputPath,
 			threshold: threshold,
 			research: research === true, // Ensure boolean
-			projectRoot: projectRoot // Pass projectRoot here
+			projectRoot: projectRoot, // Pass projectRoot here
+			id: ids, // Pass the ids parameter to the core function as 'id'
+			from: from, // Pass from parameter
+			to: to // Pass to parameter
 		};
 		// --- End Initial Checks ---
 
@@ -79,17 +102,19 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 		}
 
 		let report;
+		let coreResult;
 
 		try {
 			// --- Call Core Function (Pass context separately) ---
 			// Pass coreOptions as the first argument
 			// Pass context object { session, mcpLog } as the second argument
-			report = await analyzeTaskComplexity(
+			coreResult = await analyzeTaskComplexity(coreOptions, {
-				coreOptions, // Pass options object
+				session,
-				{ session, mcpLog: logWrapper } // Pass context object
+				mcpLog: logWrapper,
-				// Removed the explicit 'json' format argument, assuming context handling is sufficient
+				commandName: 'analyze-complexity',
-				// If issues persist, we might need to add an explicit format param to analyzeTaskComplexity
+				outputType: 'mcp'
-			);
+			});
+			report = coreResult.report;
 		} catch (error) {
 			log.error(
 				`Error in analyzeTaskComplexity core function: ${error.message}`
@@ -125,8 +150,11 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 			};
 		}
 
-		// Added a check to ensure report is defined before accessing its properties
+		if (
-		if (!report || typeof report !== 'object') {
+			!coreResult ||
+			!coreResult.report ||
+			typeof coreResult.report !== 'object'
+		) {
 			log.error(
 				'Core analysis function returned an invalid or undefined response.'
 			);
@@ -141,8 +169,8 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 
 		try {
 			// Ensure complexityAnalysis exists and is an array
-			const analysisArray = Array.isArray(report.complexityAnalysis)
+			const analysisArray = Array.isArray(coreResult.report.complexityAnalysis)
-				? report.complexityAnalysis
+				? coreResult.report.complexityAnalysis
 				: [];
 
 			// Count tasks by complexity (remains the same)
@@ -159,15 +187,16 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 			return {
 				success: true,
 				data: {
-					message: `Task complexity analysis complete. Report saved to ${outputPath}`, // Use outputPath from args
+					message: `Task complexity analysis complete. Report saved to ${outputPath}`,
-					reportPath: outputPath, // Use outputPath from args
+					reportPath: outputPath,
 					reportSummary: {
 						taskCount: analysisArray.length,
 						highComplexityTasks,
 						mediumComplexityTasks,
 						lowComplexityTasks
 					},
-					fullReport: report // Now includes the full report
+					fullReport: coreResult.report,
+					telemetryData: coreResult.telemetryData
 				}
 			};
 		} catch (parseError) {

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

@@ -63,12 +63,18 @@ export async function expandAllTasksDirect(args, log, context = {}) {
 			{ session, mcpLog, projectRoot }
 		);
 
-		// Core function now returns a summary object
+		// Core function now returns a summary object including the *aggregated* telemetryData
 		return {
 			success: true,
 			data: {
 				message: `Expand all operation completed. Expanded: ${result.expandedCount}, Failed: ${result.failedCount}, Skipped: ${result.skippedCount}`,
-				details: result // Include the full result details
+				details: {
+					expandedCount: result.expandedCount,
+					failedCount: result.failedCount,
+					skippedCount: result.skippedCount,
+					tasksToExpand: result.tasksToExpand
+				},
+				telemetryData: result.telemetryData // Pass the aggregated object
 			}
 		};
 	} catch (error) {

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

@@ -193,13 +193,19 @@ export async function expandTaskDirect(args, log, context = {}) {
 			if (!wasSilent) enableSilentMode();
 
 			// Call the core expandTask function with the wrapped logger and projectRoot
-			const updatedTaskResult = await expandTask(
+			const coreResult = await expandTask(
 				tasksPath,
 				taskId,
 				numSubtasks,
 				useResearch,
 				additionalContext,
-				{ mcpLog, session, projectRoot },
+				{
+					mcpLog,
+					session,
+					projectRoot,
+					commandName: 'expand-task',
+					outputType: 'mcp'
+				},
 				forceFlag
 			);
 
@@ -215,16 +221,17 @@ export async function expandTaskDirect(args, log, context = {}) {
 				? updatedTask.subtasks.length - subtasksCountBefore
 				: 0;
 
-			// Return the result
+			// Return the result, including telemetryData
 			log.info(
 				`Successfully expanded task ${taskId} with ${subtasksAdded} new subtasks`
 			);
 			return {
 				success: true,
 				data: {
-					task: updatedTask,
+					task: coreResult.task,
 					subtasksAdded,
-					hasExistingSubtasks
+					hasExistingSubtasks,
+					telemetryData: coreResult.telemetryData
 				},
 				fromCache: false
 			};

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

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

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

@@ -31,6 +31,7 @@ export async function parsePRDDirect(args, log, context = {}) {
 		numTasks: numTasksArg,
 		force,
 		append,
+		research,
 		projectRoot
 	} = args;
 
@@ -105,19 +106,23 @@ export async function parsePRDDirect(args, log, context = {}) {
 		}
 	}
 
-	const useForce = force === true;
+	if (append) {
-	const useAppend = append === true;
-	if (useAppend) {
 		logWrapper.info('Append mode enabled.');
-		if (useForce) {
+		if (force) {
 			logWrapper.warn(
 				'Both --force and --append flags were provided. --force takes precedence; append mode will be ignored.'
 			);
 		}
 	}
 
+	if (research) {
+		logWrapper.info(
+			'Research mode enabled. Using Perplexity AI for enhanced PRD analysis.'
+		);
+	}
+
 	logWrapper.info(
-		`Parsing PRD via direct function. Input: ${inputPath}, Output: ${outputPath}, NumTasks: ${numTasks}, Force: ${useForce}, Append: ${useAppend}, ProjectRoot: ${projectRoot}`
+		`Parsing PRD via direct function. Input: ${inputPath}, Output: ${outputPath}, NumTasks: ${numTasks}, Force: ${force}, Append: ${append}, Research: ${research}, ProjectRoot: ${projectRoot}`
 	);
 
 	const wasSilent = isSilentMode();
@@ -131,21 +136,29 @@ export async function parsePRDDirect(args, log, context = {}) {
 			inputPath,
 			outputPath,
 			numTasks,
-			{ session, mcpLog: logWrapper, projectRoot, useForce, useAppend },
+			{
+				session,
+				mcpLog: logWrapper,
+				projectRoot,
+				force,
+				append,
+				research,
+				commandName: 'parse-prd',
+				outputType: 'mcp'
+			},
 			'json'
 		);
 
-		// parsePRD returns { success: true, tasks: processedTasks } on success
+		// Adjust check for the new return structure
-		if (result && result.success && Array.isArray(result.tasks)) {
+		if (result && result.success) {
-			logWrapper.success(
+			const successMsg = `Successfully parsed PRD and generated tasks in ${result.tasksPath}`;
-				`Successfully parsed PRD. Generated ${result.tasks.length} tasks.`
+			logWrapper.success(successMsg);
-			);
 			return {
 				success: true,
 				data: {
-					message: `Successfully parsed PRD and generated ${result.tasks.length} tasks.`,
+					message: successMsg,
-					outputPath: outputPath,
+					outputPath: result.tasksPath,
-					taskCount: result.tasks.length
+					telemetryData: result.telemetryData
 				}
 			};
 		} else {

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

@@ -9,7 +9,7 @@ import {
 	disableSilentMode,
 	isSilentMode
 } from '../../../../scripts/modules/utils.js';
-
+import { nextTaskDirect } from './next-task.js';
 /**
  * Direct function wrapper for setTaskStatus with error handling.
  *
@@ -19,7 +19,7 @@ import {
  */
 export async function setTaskStatusDirect(args, log) {
 	// Destructure expected args, including the resolved tasksJsonPath
-	const { tasksJsonPath, id, status } = args;
+	const { tasksJsonPath, id, status, complexityReportPath } = args;
 	try {
 		log.info(`Setting task status with args: ${JSON.stringify(args)}`);
 
@@ -85,6 +85,39 @@ export async function setTaskStatusDirect(args, log) {
 				},
 				fromCache: false // This operation always modifies state and should never be cached
 			};
+
+			// If the task was completed, attempt to fetch the next task
+			if (result.data.status === 'done') {
+				try {
+					log.info(`Attempting to fetch next task for task ${taskId}`);
+					const nextResult = await nextTaskDirect(
+						{
+							tasksJsonPath: tasksJsonPath,
+							reportPath: complexityReportPath
+						},
+						log
+					);
+
+					if (nextResult.success) {
+						log.info(
+							`Successfully retrieved next task: ${nextResult.data.nextTask}`
+						);
+						result.data = {
+							...result.data,
+							nextTask: nextResult.data.nextTask,
+							isNextSubtask: nextResult.data.isSubtask,
+							nextSteps: nextResult.data.nextSteps
+						};
+					} else {
+						log.warn(
+							`Failed to retrieve next task: ${nextResult.error?.message || 'Unknown error'}`
+						);
+					}
+				} catch (nextErr) {
+					log.error(`Error retrieving next task: ${nextErr.message}`);
+				}
+			}
+
 			return result;
 		} catch (error) {
 			log.error(`Error setting task status: ${error.message}`);

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

@@ -108,18 +108,24 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 
 		try {
 			// Execute core updateSubtaskById function
-			const updatedSubtask = await updateSubtaskById(
+			const coreResult = await updateSubtaskById(
 				tasksPath,
 				subtaskIdStr,
 				prompt,
 				useResearch,
-				{ mcpLog: logWrapper, session, projectRoot },
+				{
+					mcpLog: logWrapper,
+					session,
+					projectRoot,
+					commandName: 'update-subtask',
+					outputType: 'mcp'
+				},
 				'json'
 			);
 
-			if (updatedSubtask === null) {
+			if (!coreResult || coreResult.updatedSubtask === null) {
 				const message = `Subtask ${id} or its parent task not found.`;
-				logWrapper.error(message); // Log as error since it couldn't be found
+				logWrapper.error(message);
 				return {
 					success: false,
 					error: { code: 'SUBTASK_NOT_FOUND', message: message },
@@ -136,9 +142,10 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 					message: `Successfully updated subtask with ID ${subtaskIdStr}`,
 					subtaskId: subtaskIdStr,
 					parentId: subtaskIdStr.split('.')[0],
-					subtask: updatedSubtask,
+					subtask: coreResult.updatedSubtask,
 					tasksPath,
-					useResearch
+					useResearch,
+					telemetryData: coreResult.telemetryData
 				},
 				fromCache: false
 			};

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

@@ -110,7 +110,7 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 
 		try {
 			// Execute core updateTaskById function with proper parameters
-			const updatedTask = await updateTaskById(
+			const coreResult = await updateTaskById(
 				tasksPath,
 				taskId,
 				prompt,
@@ -118,19 +118,26 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 				{
 					mcpLog: logWrapper,
 					session,
-					projectRoot
+					projectRoot,
+					commandName: 'update-task',
+					outputType: 'mcp'
 				},
 				'json'
 			);
 
-			// Check if the core function indicated the task wasn't updated (e.g., status was 'done')
+			// Check if the core function returned null or an object without success
-			if (updatedTask === null) {
+			if (!coreResult || coreResult.updatedTask === null) {
 				// Core function logs the reason, just return success with info
 				const message = `Task ${taskId} was not updated (likely already completed).`;
 				logWrapper.info(message);
 				return {
 					success: true,
-					data: { message: message, taskId: taskId, updated: false },
+					data: {
+						message: message,
+						taskId: taskId,
+						updated: false,
+						telemetryData: coreResult?.telemetryData
+					},
 					fromCache: false
 				};
 			}
@@ -146,7 +153,8 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 					tasksPath: tasksPath,
 					useResearch: useResearch,
 					updated: true,
-					updatedTask: updatedTask
+					updatedTask: coreResult.updatedTask,
+					telemetryData: coreResult.telemetryData
 				},
 				fromCache: false
 			};

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

@@ -85,7 +85,6 @@ export async function updateTasksDirect(args, log, context = {}) {
 			'json'
 		);
 
-		// updateTasks returns { success: true, updatedTasks: [...] } on success
 		if (result && result.success && Array.isArray(result.updatedTasks)) {
 			logWrapper.success(
 				`Successfully updated ${result.updatedTasks.length} tasks.`
@@ -95,7 +94,8 @@ export async function updateTasksDirect(args, log, context = {}) {
 				data: {
 					message: `Successfully updated ${result.updatedTasks.length} tasks.`,
 					tasksFile,
-					updatedCount: result.updatedTasks.length
+					updatedCount: result.updatedTasks.length,
+					telemetryData: result.telemetryData
 				}
 			};
 		} else {

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

@@ -30,6 +30,7 @@ import { addDependencyDirect } from './direct-functions/add-dependency.js';
 import { removeTaskDirect } from './direct-functions/remove-task.js';
 import { initializeProjectDirect } from './direct-functions/initialize-project.js';
 import { modelsDirect } from './direct-functions/models.js';
+import { moveTaskDirect } from './direct-functions/move-task.js';
 
 // Re-export utility functions
 export { findTasksJsonPath } from './utils/path-utils.js';
@@ -60,7 +61,8 @@ export const directFunctions = new Map([
 	['addDependencyDirect', addDependencyDirect],
 	['removeTaskDirect', removeTaskDirect],
 	['initializeProjectDirect', initializeProjectDirect],
-	['modelsDirect', modelsDirect]
+	['modelsDirect', modelsDirect],
+	['moveTaskDirect', moveTaskDirect]
 ]);
 
 // Re-export all direct function implementations
@@ -89,5 +91,6 @@ export {
 	addDependencyDirect,
 	removeTaskDirect,
 	initializeProjectDirect,
-	modelsDirect
+	modelsDirect,
+	moveTaskDirect
 };

mcp-server/src/tools/analyze.js

@@ -49,6 +49,24 @@ export function registerAnalyzeProjectComplexityTool(server) {
 				.describe(
 					'Path to the tasks file relative to project root (default: tasks/tasks.json).'
 				),
+			ids: z
+				.string()
+				.optional()
+				.describe(
+					'Comma-separated list of task IDs to analyze specifically (e.g., "1,3,5").'
+				),
+			from: z.coerce
+				.number()
+				.int()
+				.positive()
+				.optional()
+				.describe('Starting task ID in a range to analyze.'),
+			to: z.coerce
+				.number()
+				.int()
+				.positive()
+				.optional()
+				.describe('Ending task ID in a range to analyze.'),
 			projectRoot: z
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
@@ -107,7 +125,10 @@ export function registerAnalyzeProjectComplexityTool(server) {
 						outputPath: outputPath,
 						threshold: args.threshold,
 						research: args.research,
-						projectRoot: args.projectRoot
+						projectRoot: args.projectRoot,
+						ids: args.ids,
+						from: args.from,
+						to: args.to
 					},
 					log,
 					{ session }

mcp-server/src/tools/index.js

@@ -28,6 +28,7 @@ import { registerAddDependencyTool } from './add-dependency.js';
 import { registerRemoveTaskTool } from './remove-task.js';
 import { registerInitializeProjectTool } from './initialize-project.js';
 import { registerModelsTool } from './models.js';
+import { registerMoveTaskTool } from './move-task.js';
 
 /**
  * Register all Task Master tools with the MCP server
@@ -61,6 +62,7 @@ export function registerTaskMasterTools(server) {
 		registerRemoveTaskTool(server);
 		registerRemoveSubtaskTool(server);
 		registerClearSubtasksTool(server);
+		registerMoveTaskTool(server);
 
 		// Group 5: Task Analysis & Expansion
 		registerAnalyzeProjectComplexityTool(server);

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

@@ -0,0 +1,129 @@
+/**
+ * tools/move-task.js
+ * Tool for moving tasks or subtasks to a new position
+ */
+
+import { z } from 'zod';
+import {
+	handleApiResult,
+	createErrorResponse,
+	withNormalizedProjectRoot
+} from './utils.js';
+import { moveTaskDirect } from '../core/task-master-core.js';
+import { findTasksJsonPath } from '../core/utils/path-utils.js';
+
+/**
+ * Register the moveTask tool with the MCP server
+ * @param {Object} server - FastMCP server instance
+ */
+export function registerMoveTaskTool(server) {
+	server.addTool({
+		name: 'move_task',
+		description: 'Move a task or subtask to a new position',
+		parameters: z.object({
+			from: z
+				.string()
+				.describe(
+					'ID of the task/subtask to move (e.g., "5" or "5.2"). Can be comma-separated to move multiple tasks (e.g., "5,6,7")'
+				),
+			to: z
+				.string()
+				.describe(
+					'ID of the destination (e.g., "7" or "7.3"). Must match the number of source IDs if comma-separated'
+				),
+			file: z.string().optional().describe('Custom path to tasks.json file'),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (typically derived from session)'
+				)
+		}),
+		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+			try {
+				// Find tasks.json path if not provided
+				let tasksJsonPath = args.file;
+
+				if (!tasksJsonPath) {
+					tasksJsonPath = findTasksJsonPath(args, log);
+				}
+
+				// Parse comma-separated IDs
+				const fromIds = args.from.split(',').map((id) => id.trim());
+				const toIds = args.to.split(',').map((id) => id.trim());
+
+				// Validate matching IDs count
+				if (fromIds.length !== toIds.length) {
+					return createErrorResponse(
+						'The number of source and destination IDs must match',
+						'MISMATCHED_ID_COUNT'
+					);
+				}
+
+				// If moving multiple tasks
+				if (fromIds.length > 1) {
+					const results = [];
+					// Move tasks one by one, only generate files on the last move
+					for (let i = 0; i < fromIds.length; i++) {
+						const fromId = fromIds[i];
+						const toId = toIds[i];
+
+						// Skip if source and destination are the same
+						if (fromId === toId) {
+							log.info(`Skipping ${fromId} -> ${toId} (same ID)`);
+							continue;
+						}
+
+						const shouldGenerateFiles = i === fromIds.length - 1;
+						const result = await moveTaskDirect(
+							{
+								sourceId: fromId,
+								destinationId: toId,
+								tasksJsonPath,
+								projectRoot: args.projectRoot
+							},
+							log,
+							{ session }
+						);
+
+						if (!result.success) {
+							log.error(
+								`Failed to move ${fromId} to ${toId}: ${result.error.message}`
+							);
+						} else {
+							results.push(result.data);
+						}
+					}
+
+					return {
+						success: true,
+						data: {
+							moves: results,
+							message: `Successfully moved ${results.length} tasks`
+						}
+					};
+				} else {
+					// Moving a single task
+					return handleApiResult(
+						await moveTaskDirect(
+							{
+								sourceId: args.from,
+								destinationId: args.to,
+								tasksJsonPath,
+								projectRoot: args.projectRoot
+							},
+							log,
+							{ session }
+						),
+						log
+					);
+				}
+			} catch (error) {
+				return createErrorResponse(
+					`Failed to move task: ${error.message}`,
+					'MOVE_TASK_ERROR'
+				);
+			}
+		})
+	});
+}

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

@@ -49,6 +49,13 @@ export function registerParsePRDTool(server) {
 				.optional()
 				.default(false)
 				.describe('Append generated tasks to existing file.'),
+			research: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe(
+					'Use the research model for research-backed task generation, providing more comprehensive, accurate and up-to-date task details.'
+				),
 			projectRoot: z
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
@@ -68,6 +75,7 @@ export function registerParsePRDTool(server) {
 						numTasks: args.numTasks,
 						force: args.force,
 						append: args.append,
+						research: args.research,
 						projectRoot: args.projectRoot
 					},
 					log,

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

@@ -9,8 +9,14 @@ import {
 	createErrorResponse,
 	withNormalizedProjectRoot
 } from './utils.js';
-import { setTaskStatusDirect } from '../core/task-master-core.js';
+import {
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
+	setTaskStatusDirect,
+	nextTaskDirect
+} from '../core/task-master-core.js';
+import {
+	findTasksJsonPath,
+	findComplexityReportPath
+} from '../core/utils/path-utils.js';
 import { TASK_STATUS_OPTIONS } from '../../../src/constants/task-status.js';
 
 /**
@@ -33,6 +39,12 @@ export function registerSetTaskStatusTool(server) {
 					"New status to set (e.g., 'pending', 'done', 'in-progress', 'review', 'deferred', 'cancelled'."
 				),
 			file: z.string().optional().describe('Absolute path to the tasks file'),
+			complexityReport: z
+				.string()
+				.optional()
+				.describe(
+					'Path to the complexity report file (relative to project root or absolute)'
+				),
 			projectRoot: z
 				.string()
 				.describe('The directory of the project. Must be an absolute path.')
@@ -55,11 +67,23 @@ export function registerSetTaskStatusTool(server) {
 					);
 				}
 
+				let complexityReportPath;
+				try {
+					complexityReportPath = findComplexityReportPath(
+						args.projectRoot,
+						args.complexityReport,
+						log
+					);
+				} catch (error) {
+					log.error(`Error finding complexity report: ${error.message}`);
+				}
+
 				const result = await setTaskStatusDirect(
 					{
 						tasksJsonPath: tasksJsonPath,
 						id: args.id,
-						status: args.status
+						status: args.status,
+						complexityReportPath
 					},
 					log
 				);

mcp-server/src/tools/utils.js

@@ -22,7 +22,7 @@ import {
  */
 function getProjectRoot(projectRootRaw, log) {
 	// PRECEDENCE ORDER:
-	// 1. Environment variable override
+	// 1. Environment variable override (TASK_MASTER_PROJECT_ROOT)
 	// 2. Explicitly provided projectRoot in args
 	// 3. Previously found/cached project root
 	// 4. Current directory if it has project markers
@@ -578,6 +578,7 @@ function getRawProjectRootFromSession(session, log) {
 /**
  * Higher-order function to wrap MCP tool execute methods.
  * Ensures args.projectRoot is present and normalized before execution.
+ * Uses TASK_MASTER_PROJECT_ROOT environment variable with proper precedence.
  * @param {Function} executeFn - The original async execute(args, context) function.
  * @returns {Function} The wrapped async execute function.
  */
@@ -588,31 +589,52 @@ function withNormalizedProjectRoot(executeFn) {
 		let rootSource = 'unknown';
 
 		try {
-			// Determine raw root: prioritize args, then session
+			// PRECEDENCE ORDER:
-			let rawRoot = args.projectRoot;
+			// 1. TASK_MASTER_PROJECT_ROOT environment variable (from process.env or session)
-			if (!rawRoot) {
+			// 2. args.projectRoot (explicitly provided)
-				rawRoot = getRawProjectRootFromSession(session, log);
+			// 3. Session-based project root resolution
-				rootSource = 'session';
+			// 4. Current directory fallback
-			} else {
-				rootSource = 'args';
-			}
 
-			if (!rawRoot) {
+			// 1. Check for TASK_MASTER_PROJECT_ROOT environment variable first
-				log.error('Could not determine project root from args or session.');
+			if (process.env.TASK_MASTER_PROJECT_ROOT) {
-				return createErrorResponse(
+				const envRoot = process.env.TASK_MASTER_PROJECT_ROOT;
-					'Could not determine project root. Please provide projectRoot argument or ensure session contains root info.'
+				normalizedRoot = path.isAbsolute(envRoot)
-				);
+					? envRoot
+					: path.resolve(process.cwd(), envRoot);
+				rootSource = 'TASK_MASTER_PROJECT_ROOT environment variable';
+				log.info(`Using project root from ${rootSource}: ${normalizedRoot}`);
+			}
+			// Also check session environment variables for TASK_MASTER_PROJECT_ROOT
+			else if (session?.env?.TASK_MASTER_PROJECT_ROOT) {
+				const envRoot = session.env.TASK_MASTER_PROJECT_ROOT;
+				normalizedRoot = path.isAbsolute(envRoot)
+					? envRoot
+					: path.resolve(process.cwd(), envRoot);
+				rootSource = 'TASK_MASTER_PROJECT_ROOT session environment variable';
+				log.info(`Using project root from ${rootSource}: ${normalizedRoot}`);
+			}
+			// 2. If no environment variable, try args.projectRoot
+			else if (args.projectRoot) {
+				normalizedRoot = normalizeProjectRoot(args.projectRoot, log);
+				rootSource = 'args.projectRoot';
+				log.info(`Using project root from ${rootSource}: ${normalizedRoot}`);
+			}
+			// 3. If no args.projectRoot, try session-based resolution
+			else {
+				const sessionRoot = getProjectRootFromSession(session, log);
+				if (sessionRoot) {
+					normalizedRoot = sessionRoot; // getProjectRootFromSession already normalizes
+					rootSource = 'session';
+					log.info(`Using project root from ${rootSource}: ${normalizedRoot}`);
+				}
 			}
-
-			// Normalize the determined raw root
-			normalizedRoot = normalizeProjectRoot(rawRoot, log);
 
 			if (!normalizedRoot) {
 				log.error(
-					`Failed to normalize project root obtained from ${rootSource}: ${rawRoot}`
+					'Could not determine project root from environment, args, or session.'
 				);
 				return createErrorResponse(
-					`Invalid project root provided or derived from ${rootSource}: ${rawRoot}`
+					'Could not determine project root. Please provide projectRoot argument or ensure TASK_MASTER_PROJECT_ROOT environment variable is set.'
 				);
 			}
 

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "task-master-ai",
-	"version": "0.13.2",
+	"version": "0.15.0",
 	"description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
 	"main": "index.js",
 	"type": "module",
@@ -39,23 +39,29 @@
 	"author": "Eyal Toledano",
 	"license": "MIT WITH Commons-Clause",
 	"dependencies": {
+		"@ai-sdk/amazon-bedrock": "^2.2.9",
 		"@ai-sdk/anthropic": "^1.2.10",
 		"@ai-sdk/azure": "^1.3.17",
 		"@ai-sdk/google": "^1.2.13",
+		"@ai-sdk/google-vertex": "^2.2.23",
 		"@ai-sdk/mistral": "^1.2.7",
 		"@ai-sdk/openai": "^1.3.20",
 		"@ai-sdk/perplexity": "^1.1.7",
 		"@ai-sdk/xai": "^1.2.15",
 		"@anthropic-ai/sdk": "^0.39.0",
+		"@aws-sdk/credential-providers": "^3.817.0",
 		"@openrouter/ai-sdk-provider": "^0.4.5",
 		"ai": "^4.3.10",
+		"boxen": "^8.0.1",
+		"chalk": "^5.4.1",
+		"cli-table3": "^0.6.5",
 		"commander": "^11.1.0",
 		"cors": "^2.8.5",
 		"dotenv": "^16.3.1",
 		"express": "^4.21.2",
 		"fastmcp": "^1.20.5",
 		"figlet": "^1.8.0",
-		"fuse.js": "^7.0.0",
+		"fuse.js": "^7.1.0",
 		"gradient-string": "^3.0.0",
 		"helmet": "^8.1.0",
 		"inquirer": "^12.5.0",
@@ -65,9 +71,6 @@
 		"openai": "^4.89.0",
 		"ora": "^8.2.0",
 		"uuid": "^11.1.0",
-		"boxen": "^8.0.1",
-		"chalk": "^5.4.1",
-		"cli-table3": "^0.6.5",
 		"zod": "^3.23.8"
 	},
 	"engines": {
@@ -92,7 +95,7 @@
 		"src/**"
 	],
 	"overrides": {
-		"node-fetch": "^3.3.2",
+		"node-fetch": "^2.6.12",
 		"whatwg-url": "^11.0.0"
 	},
 	"devDependencies": {
@@ -104,7 +107,6 @@
 		"jest": "^29.7.0",
 		"jest-environment-node": "^29.7.0",
 		"mock-fs": "^5.5.0",
-		"node-fetch": "^3.3.2",
 		"prettier": "^3.5.3",
 		"react": "^18.3.1",
 		"supertest": "^7.1.0",

scripts/modules/ai-services-unified.js

@@ -15,58 +15,76 @@ import {
 	getFallbackProvider,
 	getFallbackModelId,
 	getParametersForRole,
-	getBaseUrlForRole
+	getUserId,
+	MODEL_MAP,
+	getDebugFlag,
+	getBaseUrlForRole,
+	isApiKeySet,
+	getOllamaBaseURL,
+	getAzureBaseURL,
+	getVertexProjectId,
+	getVertexLocation
 } from './config-manager.js';
-import { log, resolveEnvVariable, findProjectRoot } from './utils.js';
+import { log, findProjectRoot, resolveEnvVariable } from './utils.js';
 
-import * as anthropic from '../../src/ai-providers/anthropic.js';
+// Import provider classes
-import * as perplexity from '../../src/ai-providers/perplexity.js';
+import {
-import * as google from '../../src/ai-providers/google.js';
+	AnthropicAIProvider,
-import * as openai from '../../src/ai-providers/openai.js';
+	PerplexityAIProvider,
-import * as xai from '../../src/ai-providers/xai.js';
+	GoogleAIProvider,
-import * as openrouter from '../../src/ai-providers/openrouter.js';
+	OpenAIProvider,
-// TODO: Import other provider modules when implemented (ollama, etc.)
+	XAIProvider,
+	OpenRouterAIProvider,
+	OllamaAIProvider,
+	BedrockAIProvider,
+	AzureProvider,
+	VertexAIProvider
+} from '../../src/ai-providers/index.js';
 
-// --- Provider Function Map ---
+// Create provider instances
-// Maps provider names (lowercase) to their respective service functions
+const PROVIDERS = {
-const PROVIDER_FUNCTIONS = {
+	anthropic: new AnthropicAIProvider(),
-	anthropic: {
+	perplexity: new PerplexityAIProvider(),
-		generateText: anthropic.generateAnthropicText,
+	google: new GoogleAIProvider(),
-		streamText: anthropic.streamAnthropicText,
+	openai: new OpenAIProvider(),
-		generateObject: anthropic.generateAnthropicObject
+	xai: new XAIProvider(),
-	},
+	openrouter: new OpenRouterAIProvider(),
-	perplexity: {
+	ollama: new OllamaAIProvider(),
-		generateText: perplexity.generatePerplexityText,
+	bedrock: new BedrockAIProvider(),
-		streamText: perplexity.streamPerplexityText,
+	azure: new AzureProvider(),
-		generateObject: perplexity.generatePerplexityObject
+	vertex: new VertexAIProvider()
-	},
-	google: {
-		// Add Google entry
-		generateText: google.generateGoogleText,
-		streamText: google.streamGoogleText,
-		generateObject: google.generateGoogleObject
-	},
-	openai: {
-		// ADD: OpenAI entry
-		generateText: openai.generateOpenAIText,
-		streamText: openai.streamOpenAIText,
-		generateObject: openai.generateOpenAIObject
-	},
-	xai: {
-		// ADD: xAI entry
-		generateText: xai.generateXaiText,
-		streamText: xai.streamXaiText,
-		generateObject: xai.generateXaiObject // Note: Object generation might be unsupported
-	},
-	openrouter: {
-		// ADD: OpenRouter entry
-		generateText: openrouter.generateOpenRouterText,
-		streamText: openrouter.streamOpenRouterText,
-		generateObject: openrouter.generateOpenRouterObject
-	}
-	// TODO: Add entries for ollama, etc. when implemented
 };
 
+// Helper function to get cost for a specific model
+function _getCostForModel(providerName, modelId) {
+	if (!MODEL_MAP || !MODEL_MAP[providerName]) {
+		log(
+			'warn',
+			`Provider "${providerName}" not found in MODEL_MAP. Cannot determine cost for model ${modelId}.`
+		);
+		return { inputCost: 0, outputCost: 0, currency: 'USD' }; // Default to zero cost
+	}
+
+	const modelData = MODEL_MAP[providerName].find((m) => m.id === modelId);
+
+	if (!modelData || !modelData.cost_per_1m_tokens) {
+		log(
+			'debug',
+			`Cost data not found for model "${modelId}" under provider "${providerName}". Assuming zero cost.`
+		);
+		return { inputCost: 0, outputCost: 0, currency: 'USD' }; // Default to zero cost
+	}
+
+	// Ensure currency is part of the returned object, defaulting if not present
+	const currency = modelData.cost_per_1m_tokens.currency || 'USD';
+
+	return {
+		inputCost: modelData.cost_per_1m_tokens.input || 0,
+		outputCost: modelData.cost_per_1m_tokens.output || 0,
+		currency: currency
+	};
+}
+
 // --- Configuration for Retries ---
 const MAX_RETRIES = 2;
 const INITIAL_RETRY_DELAY_MS = 1000;
@@ -150,14 +168,12 @@ function _resolveApiKey(providerName, session, projectRoot = null) {
 		mistral: 'MISTRAL_API_KEY',
 		azure: 'AZURE_OPENAI_API_KEY',
 		openrouter: 'OPENROUTER_API_KEY',
-		xai: 'XAI_API_KEY'
+		xai: 'XAI_API_KEY',
+		ollama: 'OLLAMA_API_KEY',
+		bedrock: 'AWS_ACCESS_KEY_ID',
+		vertex: 'GOOGLE_API_KEY'
 	};
 
-	// Double check this -- I have had to use an api key for ollama in the past
-	// if (providerName === 'ollama') {
-	// 	return null; // Ollama typically doesn't require an API key for basic setup
-	// }
-
 	const envVarName = keyMap[providerName];
 	if (!envVarName) {
 		throw new Error(
@@ -166,6 +182,12 @@ function _resolveApiKey(providerName, session, projectRoot = null) {
 	}
 
 	const apiKey = resolveEnvVariable(envVarName, session, projectRoot);
+
+	// Special handling for providers that can use alternative auth
+	if (providerName === 'ollama' || providerName === 'bedrock') {
+		return apiKey || null;
+	}
+
 	if (!apiKey) {
 		throw new Error(
 			`Required API key ${envVarName} for provider '${providerName}' is not set in environment, session, or .env file.`
@@ -186,29 +208,34 @@ function _resolveApiKey(providerName, session, projectRoot = null) {
  * @throws {Error} If the call fails after all retries.
  */
 async function _attemptProviderCallWithRetries(
-	providerApiFn,
+	provider,
+	serviceType,
 	callParams,
 	providerName,
 	modelId,
 	attemptRole
 ) {
 	let retries = 0;
-	const fnName = providerApiFn.name;
+	const fnName = serviceType;
 
 	while (retries <= MAX_RETRIES) {
 		try {
-			log(
+			if (getDebugFlag()) {
-				'info',
+				log(
-				`Attempt ${retries + 1}/${MAX_RETRIES + 1} calling ${fnName} (Provider: ${providerName}, Model: ${modelId}, Role: ${attemptRole})`
+					'info',
-			);
+					`Attempt ${retries + 1}/${MAX_RETRIES + 1} calling ${fnName} (Provider: ${providerName}, Model: ${modelId}, Role: ${attemptRole})`
+				);
+			}
 
-			// Call the specific provider function directly
+			// Call the appropriate method on the provider instance
-			const result = await providerApiFn(callParams);
+			const result = await provider[serviceType](callParams);
 
-			log(
+			if (getDebugFlag()) {
-				'info',
+				log(
-				`${fnName} succeeded for role ${attemptRole} (Provider: ${providerName}) on attempt ${retries + 1}`
+					'info',
-			);
+					`${fnName} succeeded for role ${attemptRole} (Provider: ${providerName}) on attempt ${retries + 1}`
+				);
+			}
 			return result;
 		} catch (error) {
 			log(
@@ -221,13 +248,13 @@ async function _attemptProviderCallWithRetries(
 				const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, retries - 1);
 				log(
 					'info',
-					`Retryable error detected. Retrying in ${delay / 1000}s...`
+					`Something went wrong on the provider side. Retrying in ${delay / 1000}s...`
 				);
 				await new Promise((resolve) => setTimeout(resolve, delay));
 			} else {
 				log(
 					'error',
-					`Non-retryable error or max retries reached for role ${attemptRole} (${fnName} / ${providerName}).`
+					`Something went wrong on the provider side. Max retries reached for role ${attemptRole} (${fnName} / ${providerName}).`
 				);
 				throw error;
 			}
@@ -243,7 +270,15 @@ async function _attemptProviderCallWithRetries(
  * Base logic for unified service functions.
  * @param {string} serviceType - Type of service ('generateText', 'streamText', 'generateObject').
  * @param {object} params - Original parameters passed to the service function.
+ * @param {string} params.role - The initial client role.
+ * @param {object} [params.session=null] - Optional MCP session object.
  * @param {string} [params.projectRoot] - Optional project root path.
+ * @param {string} params.commandName - Name of the command invoking the service.
+ * @param {string} params.outputType - 'cli' or 'mcp'.
+ * @param {string} [params.systemPrompt] - Optional system prompt.
+ * @param {string} [params.prompt] - The prompt for the AI.
+ * @param {string} [params.schema] - The Zod schema for the expected object.
+ * @param {string} [params.objectName] - Name for object/tool.
  * @returns {Promise<any>} Result from the underlying provider call.
  */
 async function _unifiedServiceRunner(serviceType, params) {
@@ -255,15 +290,21 @@ async function _unifiedServiceRunner(serviceType, params) {
 		prompt,
 		schema,
 		objectName,
+		commandName,
+		outputType,
 		...restApiParams
 	} = params;
-	log('info', `${serviceType}Service called`, {
+	if (getDebugFlag()) {
-		role: initialRole,
+		log('info', `${serviceType}Service called`, {
-		projectRoot
+			role: initialRole,
-	});
+			commandName,
+			outputType,
+			projectRoot
+		});
+	}
 
-	// Determine the effective project root (passed in or detected)
 	const effectiveProjectRoot = projectRoot || findProjectRoot();
+	const userId = getUserId(effectiveProjectRoot);
 
 	let sequence;
 	if (initialRole === 'main') {
@@ -289,15 +330,14 @@ async function _unifiedServiceRunner(serviceType, params) {
 			modelId,
 			apiKey,
 			roleParams,
-			providerFnSet,
+			provider,
-			providerApiFn,
+			baseURL,
-			baseUrl;
+			providerResponse,
+			telemetryData = null;
 
 		try {
 			log('info', `New AI service call with role: ${currentRole}`);
 
-			// 1. Get Config: Provider, Model, Parameters for the current role
-			// Pass effectiveProjectRoot to config getters
 			if (currentRole === 'main') {
 				providerName = getMainProvider(effectiveProjectRoot);
 				modelId = getMainModelId(effectiveProjectRoot);
@@ -330,16 +370,12 @@ async function _unifiedServiceRunner(serviceType, params) {
 				continue;
 			}
 
-			// Pass effectiveProjectRoot to getParametersForRole
+			// Get provider instance
-			roleParams = getParametersForRole(currentRole, effectiveProjectRoot);
+			provider = PROVIDERS[providerName?.toLowerCase()];
-			baseUrl = getBaseUrlForRole(currentRole, effectiveProjectRoot);
+			if (!provider) {
-
-			// 2. Get Provider Function Set
-			providerFnSet = PROVIDER_FUNCTIONS[providerName?.toLowerCase()];
-			if (!providerFnSet) {
 				log(
 					'warn',
-					`Skipping role '${currentRole}': Provider '${providerName}' not supported or map entry missing.`
+					`Skipping role '${currentRole}': Provider '${providerName}' not supported.`
 				);
 				lastError =
 					lastError ||
@@ -347,30 +383,86 @@ async function _unifiedServiceRunner(serviceType, params) {
 				continue;
 			}
 
-			// Use the original service type to get the function
+			// Check API key if needed
-			providerApiFn = providerFnSet[serviceType];
+			if (providerName?.toLowerCase() !== 'ollama') {
-			if (typeof providerApiFn !== 'function') {
+				if (!isApiKeySet(providerName, session, effectiveProjectRoot)) {
-				log(
+					log(
-					'warn',
+						'warn',
-					`Skipping role '${currentRole}': Service type '${serviceType}' not implemented for provider '${providerName}'.`
+						`Skipping role '${currentRole}' (Provider: ${providerName}): API key not set or invalid.`
-				);
-				lastError =
-					lastError ||
-					new Error(
-						`Service '${serviceType}' not implemented for provider ${providerName}`
 					);
-				continue;
+					lastError =
+						lastError ||
+						new Error(
+							`API key for provider '${providerName}' (role: ${currentRole}) is not set.`
+						);
+					continue; // Skip to the next role in the sequence
+				}
 			}
 
-			// 3. Resolve API Key (will throw if required and missing)
+			// Get base URL if configured (optional for most providers)
-			// Pass effectiveProjectRoot to _resolveApiKey
+			baseURL = getBaseUrlForRole(currentRole, effectiveProjectRoot);
+
+			// For Azure, use the global Azure base URL if role-specific URL is not configured
+			if (providerName?.toLowerCase() === 'azure' && !baseURL) {
+				baseURL = getAzureBaseURL(effectiveProjectRoot);
+				log('debug', `Using global Azure base URL: ${baseURL}`);
+			} else if (providerName?.toLowerCase() === 'ollama' && !baseURL) {
+				// For Ollama, use the global Ollama base URL if role-specific URL is not configured
+				baseURL = getOllamaBaseURL(effectiveProjectRoot);
+				log('debug', `Using global Ollama base URL: ${baseURL}`);
+			}
+
+			// Get AI parameters for the current role
+			roleParams = getParametersForRole(currentRole, effectiveProjectRoot);
 			apiKey = _resolveApiKey(
 				providerName?.toLowerCase(),
 				session,
 				effectiveProjectRoot
 			);
 
-			// 4. Construct Messages Array
+			// Prepare provider-specific configuration
+			let providerSpecificParams = {};
+
+			// Handle Vertex AI specific configuration
+			if (providerName?.toLowerCase() === 'vertex') {
+				// Get Vertex project ID and location
+				const projectId =
+					getVertexProjectId(effectiveProjectRoot) ||
+					resolveEnvVariable(
+						'VERTEX_PROJECT_ID',
+						session,
+						effectiveProjectRoot
+					);
+
+				const location =
+					getVertexLocation(effectiveProjectRoot) ||
+					resolveEnvVariable(
+						'VERTEX_LOCATION',
+						session,
+						effectiveProjectRoot
+					) ||
+					'us-central1';
+
+				// Get credentials path if available
+				const credentialsPath = resolveEnvVariable(
+					'GOOGLE_APPLICATION_CREDENTIALS',
+					session,
+					effectiveProjectRoot
+				);
+
+				// Add Vertex-specific parameters
+				providerSpecificParams = {
+					projectId,
+					location,
+					...(credentialsPath && { credentials: { credentialsFromEnv: true } })
+				};
+
+				log(
+					'debug',
+					`Using Vertex AI configuration: Project ID=${projectId}, Location=${location}`
+				);
+			}
+
 			const messages = [];
 			if (systemPrompt) {
 				messages.push({ role: 'system', content: systemPrompt });
@@ -395,37 +487,73 @@ async function _unifiedServiceRunner(serviceType, params) {
 			// }
 
 			if (prompt) {
-				// Ensure prompt exists before adding
 				messages.push({ role: 'user', content: prompt });
 			} else {
-				// Throw an error if the prompt is missing, as it's essential
 				throw new Error('User prompt content is missing.');
 			}
 
-			// 5. Prepare call parameters (using messages array)
 			const callParams = {
 				apiKey,
 				modelId,
 				maxTokens: roleParams.maxTokens,
 				temperature: roleParams.temperature,
 				messages,
-				baseUrl,
+				...(baseURL && { baseURL }),
 				...(serviceType === 'generateObject' && { schema, objectName }),
+				...providerSpecificParams,
 				...restApiParams
 			};
 
-			// 6. Attempt the call with retries
+			providerResponse = await _attemptProviderCallWithRetries(
-			const result = await _attemptProviderCallWithRetries(
+				provider,
-				providerApiFn,
+				serviceType,
 				callParams,
 				providerName,
 				modelId,
 				currentRole
 			);
 
-			log('info', `${serviceType}Service succeeded using role: ${currentRole}`);
+			if (userId && providerResponse && providerResponse.usage) {
+				try {
+					telemetryData = await logAiUsage({
+						userId,
+						commandName,
+						providerName,
+						modelId,
+						inputTokens: providerResponse.usage.inputTokens,
+						outputTokens: providerResponse.usage.outputTokens,
+						outputType
+					});
+				} catch (telemetryError) {
+					// logAiUsage already logs its own errors and returns null on failure
+					// No need to log again here, telemetryData will remain null
+				}
+			} else if (userId && providerResponse && !providerResponse.usage) {
+				log(
+					'warn',
+					`Cannot log telemetry for ${commandName} (${providerName}/${modelId}): AI result missing 'usage' data. (May be expected for streams)`
+				);
+			}
 
-			return result;
+			let finalMainResult;
+			if (serviceType === 'generateText') {
+				finalMainResult = providerResponse.text;
+			} else if (serviceType === 'generateObject') {
+				finalMainResult = providerResponse.object;
+			} else if (serviceType === 'streamText') {
+				finalMainResult = providerResponse;
+			} else {
+				log(
+					'error',
+					`Unknown serviceType in _unifiedServiceRunner: ${serviceType}`
+				);
+				finalMainResult = providerResponse;
+			}
+
+			return {
+				mainResult: finalMainResult,
+				telemetryData: telemetryData
+			};
 		} catch (error) {
 			const cleanMessage = _extractErrorMessage(error);
 			log(
@@ -454,9 +582,7 @@ async function _unifiedServiceRunner(serviceType, params) {
 		}
 	}
 
-	// If loop completes, all roles failed
 	log('error', `All roles in the sequence [${sequence.join(', ')}] failed.`);
-	// Throw a new error with the cleaner message from the last failure
 	throw new Error(lastCleanErrorMessage);
 }
 
@@ -470,11 +596,16 @@ async function _unifiedServiceRunner(serviceType, params) {
  * @param {string} [params.projectRoot=null] - Optional project root path for .env fallback.
  * @param {string} params.prompt - The prompt for the AI.
  * @param {string} [params.systemPrompt] - Optional system prompt.
- * // Other specific generateText params can be included here.
+ * @param {string} params.commandName - Name of the command invoking the service.
- * @returns {Promise<string>} The generated text content.
+ * @param {string} [params.outputType='cli'] - 'cli' or 'mcp'.
+ * @returns {Promise<object>} Result object containing generated text and usage data.
  */
 async function generateTextService(params) {
-	return _unifiedServiceRunner('generateText', params);
+	// Ensure default outputType if not provided
+	const defaults = { outputType: 'cli' };
+	const combinedParams = { ...defaults, ...params };
+	// TODO: Validate commandName exists?
+	return _unifiedServiceRunner('generateText', combinedParams);
 }
 
 /**
@@ -487,11 +618,18 @@ async function generateTextService(params) {
  * @param {string} [params.projectRoot=null] - Optional project root path for .env fallback.
  * @param {string} params.prompt - The prompt for the AI.
  * @param {string} [params.systemPrompt] - Optional system prompt.
- * // Other specific streamText params can be included here.
+ * @param {string} params.commandName - Name of the command invoking the service.
- * @returns {Promise<ReadableStream<string>>} A readable stream of text deltas.
+ * @param {string} [params.outputType='cli'] - 'cli' or 'mcp'.
+ * @returns {Promise<object>} Result object containing the stream and usage data.
  */
 async function streamTextService(params) {
-	return _unifiedServiceRunner('streamText', params);
+	const defaults = { outputType: 'cli' };
+	const combinedParams = { ...defaults, ...params };
+	// TODO: Validate commandName exists?
+	// NOTE: Telemetry for streaming might be tricky as usage data often comes at the end.
+	// The current implementation logs *after* the stream is returned.
+	// We might need to adjust how usage is captured/logged for streams.
+	return _unifiedServiceRunner('streamText', combinedParams);
 }
 
 /**
@@ -507,15 +645,89 @@ async function streamTextService(params) {
  * @param {string} [params.systemPrompt] - Optional system prompt.
  * @param {string} [params.objectName='generated_object'] - Name for object/tool.
  * @param {number} [params.maxRetries=3] - Max retries for object generation.
- * @returns {Promise<object>} The generated object matching the schema.
+ * @param {string} params.commandName - Name of the command invoking the service.
+ * @param {string} [params.outputType='cli'] - 'cli' or 'mcp'.
+ * @returns {Promise<object>} Result object containing the generated object and usage data.
  */
 async function generateObjectService(params) {
 	const defaults = {
 		objectName: 'generated_object',
-		maxRetries: 3
+		maxRetries: 3,
+		outputType: 'cli'
 	};
 	const combinedParams = { ...defaults, ...params };
+	// TODO: Validate commandName exists?
 	return _unifiedServiceRunner('generateObject', combinedParams);
 }
 
-export { generateTextService, streamTextService, generateObjectService };
+// --- Telemetry Function ---
+/**
+ * Logs AI usage telemetry data.
+ * For now, it just logs to the console. Sending will be implemented later.
+ * @param {object} params - Telemetry parameters.
+ * @param {string} params.userId - Unique user identifier.
+ * @param {string} params.commandName - The command that triggered the AI call.
+ * @param {string} params.providerName - The AI provider used (e.g., 'openai').
+ * @param {string} params.modelId - The specific AI model ID used.
+ * @param {number} params.inputTokens - Number of input tokens.
+ * @param {number} params.outputTokens - Number of output tokens.
+ */
+async function logAiUsage({
+	userId,
+	commandName,
+	providerName,
+	modelId,
+	inputTokens,
+	outputTokens,
+	outputType
+}) {
+	try {
+		const isMCP = outputType === 'mcp';
+		const timestamp = new Date().toISOString();
+		const totalTokens = (inputTokens || 0) + (outputTokens || 0);
+
+		// Destructure currency along with costs
+		const { inputCost, outputCost, currency } = _getCostForModel(
+			providerName,
+			modelId
+		);
+
+		const totalCost =
+			((inputTokens || 0) / 1_000_000) * inputCost +
+			((outputTokens || 0) / 1_000_000) * outputCost;
+
+		const telemetryData = {
+			timestamp,
+			userId,
+			commandName,
+			modelUsed: modelId, // Consistent field name from requirements
+			providerName, // Keep provider name for context
+			inputTokens: inputTokens || 0,
+			outputTokens: outputTokens || 0,
+			totalTokens,
+			totalCost: parseFloat(totalCost.toFixed(6)),
+			currency // Add currency to the telemetry data
+		};
+
+		if (getDebugFlag()) {
+			log('info', 'AI Usage Telemetry:', telemetryData);
+		}
+
+		// TODO (Subtask 77.2): Send telemetryData securely to the external endpoint.
+
+		return telemetryData;
+	} catch (error) {
+		log('error', `Failed to log AI usage telemetry: ${error.message}`, {
+			error
+		});
+		// Don't re-throw; telemetry failure shouldn't block core functionality.
+		return null;
+	}
+}
+
+export {
+	generateTextService,
+	streamTextService,
+	generateObjectService,
+	logAiUsage
+};

scripts/modules/commands.js

@@ -9,10 +9,11 @@ import chalk from 'chalk';
 import boxen from 'boxen';
 import fs from 'fs';
 import https from 'https';
+import http from 'http';
 import inquirer from 'inquirer';
 import ora from 'ora'; // Import ora
 
-import { log, readJSON } from './utils.js';
+import { log, readJSON, findProjectRoot } from './utils.js';
 import {
 	parsePRD,
 	updateTasks,
@@ -30,7 +31,8 @@ import {
 	updateSubtaskById,
 	removeTask,
 	findTaskById,
-	taskExists
+	taskExists,
+	moveTask
 } from './task-manager.js';
 
 import {
@@ -47,7 +49,8 @@ import {
 	writeConfig,
 	ConfigurationError,
 	isConfigFilePresent,
-	getAvailableModels
+	getAvailableModels,
+	getBaseUrlForRole
 } from './config-manager.js';
 
 import {
@@ -62,7 +65,8 @@ import {
 	stopLoadingIndicator,
 	displayModelConfiguration,
 	displayAvailableModels,
-	displayApiKeyStatus
+	displayApiKeyStatus,
+	displayAiUsageSummary
 } from './ui.js';
 
 import { initializeProject } from '../init.js';
@@ -72,7 +76,6 @@ import {
 	setModel,
 	getApiKeyStatusReport
 } from './task-manager/models.js';
-import { findProjectRoot } from './utils.js';
 import {
 	isValidTaskStatus,
 	TASK_STATUS_OPTIONS
@@ -151,6 +154,64 @@ async function runInteractiveSetup(projectRoot) {
 		});
 	}
 
+	// Helper function to fetch Ollama models (duplicated for CLI context)
+	function fetchOllamaModelsCLI(baseURL = 'http://localhost:11434/api') {
+		return new Promise((resolve) => {
+			try {
+				// Parse the base URL to extract hostname, port, and base path
+				const url = new URL(baseURL);
+				const isHttps = url.protocol === 'https:';
+				const port = url.port || (isHttps ? 443 : 80);
+				const basePath = url.pathname.endsWith('/')
+					? url.pathname.slice(0, -1)
+					: url.pathname;
+
+				const options = {
+					hostname: url.hostname,
+					port: parseInt(port, 10),
+					path: `${basePath}/tags`,
+					method: 'GET',
+					headers: {
+						Accept: 'application/json'
+					}
+				};
+
+				const requestLib = isHttps ? https : http;
+				const req = requestLib.request(options, (res) => {
+					let data = '';
+					res.on('data', (chunk) => {
+						data += chunk;
+					});
+					res.on('end', () => {
+						if (res.statusCode === 200) {
+							try {
+								const parsedData = JSON.parse(data);
+								resolve(parsedData.models || []); // Return the array of models
+							} catch (e) {
+								console.error('Error parsing Ollama response:', e);
+								resolve(null); // Indicate failure
+							}
+						} else {
+							console.error(
+								`Ollama API request failed with status code: ${res.statusCode}`
+							);
+							resolve(null); // Indicate failure
+						}
+					});
+				});
+
+				req.on('error', (e) => {
+					console.error('Error fetching Ollama models:', e);
+					resolve(null); // Indicate failure
+				});
+				req.end();
+			} catch (e) {
+				console.error('Error parsing Ollama base URL:', e);
+				resolve(null); // Indicate failure
+			}
+		});
+	}
+
 	// Helper to get choices and default index for a role
 	const getPromptData = (role, allowNone = false) => {
 		const currentModel = currentModels[role]; // Use the fetched data
@@ -178,6 +239,16 @@ async function runInteractiveSetup(projectRoot) {
 			value: '__CUSTOM_OPENROUTER__'
 		};
 
+		const customOllamaOption = {
+			name: '* Custom Ollama model', // Symbol updated
+			value: '__CUSTOM_OLLAMA__'
+		};
+
+		const customBedrockOption = {
+			name: '* Custom Bedrock model', // Add Bedrock custom option
+			value: '__CUSTOM_BEDROCK__'
+		};
+
 		let choices = [];
 		let defaultIndex = 0; // Default to 'Cancel'
 
@@ -223,6 +294,8 @@ async function runInteractiveSetup(projectRoot) {
 		}
 		commonPrefix.push(cancelOption);
 		commonPrefix.push(customOpenRouterOption);
+		commonPrefix.push(customOllamaOption);
+		commonPrefix.push(customBedrockOption);
 
 		let prefixLength = commonPrefix.length; // Initial prefix length
 
@@ -353,6 +426,82 @@ async function runInteractiveSetup(projectRoot) {
 				setupSuccess = false;
 				return true; // Continue setup, but mark as failed
 			}
+		} else if (selectedValue === '__CUSTOM_OLLAMA__') {
+			isCustomSelection = true;
+			const { customId } = await inquirer.prompt([
+				{
+					type: 'input',
+					name: 'customId',
+					message: `Enter the custom Ollama Model ID for the ${role} role:`
+				}
+			]);
+			if (!customId) {
+				console.log(chalk.yellow('No custom ID entered. Skipping role.'));
+				return true; // Continue setup, but don't set this role
+			}
+			modelIdToSet = customId;
+			providerHint = 'ollama';
+			// Get the Ollama base URL from config for this role
+			const ollamaBaseURL = getBaseUrlForRole(role, projectRoot);
+			// Validate against live Ollama list
+			const ollamaModels = await fetchOllamaModelsCLI(ollamaBaseURL);
+			if (ollamaModels === null) {
+				console.error(
+					chalk.red(
+						`Error: Unable to connect to Ollama server at ${ollamaBaseURL}. Please ensure Ollama is running and try again.`
+					)
+				);
+				setupSuccess = false;
+				return true; // Continue setup, but mark as failed
+			} else if (!ollamaModels.some((m) => m.model === modelIdToSet)) {
+				console.error(
+					chalk.red(
+						`Error: Model ID "${modelIdToSet}" not found in the Ollama instance. Please verify the model is pulled and available.`
+					)
+				);
+				console.log(
+					chalk.yellow(
+						`You can check available models with: curl ${ollamaBaseURL}/tags`
+					)
+				);
+				setupSuccess = false;
+				return true; // Continue setup, but mark as failed
+			}
+		} else if (selectedValue === '__CUSTOM_BEDROCK__') {
+			isCustomSelection = true;
+			const { customId } = await inquirer.prompt([
+				{
+					type: 'input',
+					name: 'customId',
+					message: `Enter the custom Bedrock Model ID for the ${role} role (e.g., anthropic.claude-3-sonnet-20240229-v1:0):`
+				}
+			]);
+			if (!customId) {
+				console.log(chalk.yellow('No custom ID entered. Skipping role.'));
+				return true; // Continue setup, but don't set this role
+			}
+			modelIdToSet = customId;
+			providerHint = 'bedrock';
+
+			// Check if AWS environment variables exist
+			if (
+				!process.env.AWS_ACCESS_KEY_ID ||
+				!process.env.AWS_SECRET_ACCESS_KEY
+			) {
+				console.error(
+					chalk.red(
+						`Error: AWS_ACCESS_KEY_ID and/or AWS_SECRET_ACCESS_KEY environment variables are missing. Please set them before using custom Bedrock models.`
+					)
+				);
+				setupSuccess = false;
+				return true; // Continue setup, but mark as failed
+			}
+
+			console.log(
+				chalk.blue(
+					`Custom Bedrock model "${modelIdToSet}" will be used. No validation performed.`
+				)
+			);
 		} else if (
 			selectedValue &&
 			typeof selectedValue === 'object' &&
@@ -506,6 +655,10 @@ function registerCommands(programInstance) {
 			'--append',
 			'Append new tasks to existing tasks.json instead of overwriting'
 		)
+		.option(
+			'-r, --research',
+			'Use Perplexity AI for research-backed task generation, providing more comprehensive and accurate task breakdown'
+		)
 		.action(async (file, options) => {
 			// Use input option if file argument not provided
 			const inputFile = file || options.input;
@@ -514,8 +667,9 @@ function registerCommands(programInstance) {
 			const outputPath = options.output;
 			const force = options.force || false;
 			const append = options.append || false;
+			const research = options.research || false;
 			let useForce = force;
-			let useAppend = false;
+			let useAppend = append;
 
 			// Helper function to check if tasks.json exists and confirm overwrite
 			async function confirmOverwriteIfNeeded() {
@@ -543,10 +697,11 @@ function registerCommands(programInstance) {
 						if (!(await confirmOverwriteIfNeeded())) return;
 
 						console.log(chalk.blue(`Generating ${numTasks} tasks...`));
-						spinner = ora('Parsing PRD and generating tasks...').start();
+						spinner = ora('Parsing PRD and generating tasks...\n').start();
 						await parsePRD(defaultPrdPath, outputPath, numTasks, {
-							useAppend,
+							append: useAppend, // Changed key from useAppend to append
-							useForce
+							force: useForce, // Changed key from useForce to force
+							research: research
 						});
 						spinner.succeed('Tasks generated successfully!');
 						return;
@@ -570,13 +725,15 @@ function registerCommands(programInstance) {
 								'  -o, --output <file>      Output file path (default: "tasks/tasks.json")\n' +
 								'  -n, --num-tasks <number> Number of tasks to generate (default: 10)\n' +
 								'  -f, --force              Skip confirmation when overwriting existing tasks\n' +
-								'  --append                 Append new tasks to existing tasks.json instead of overwriting\n\n' +
+								'  --append                 Append new tasks to existing tasks.json instead of overwriting\n' +
+								'  -r, --research           Use Perplexity AI for research-backed task generation\n\n' +
 								chalk.cyan('Example:') +
 								'\n' +
 								'  task-master parse-prd requirements.txt --num-tasks 15\n' +
 								'  task-master parse-prd --input=requirements.txt\n' +
 								'  task-master parse-prd --force\n' +
-								'  task-master parse-prd requirements_v2.txt --append\n\n' +
+								'  task-master parse-prd requirements_v2.txt --append\n' +
+								'  task-master parse-prd requirements.txt --research\n\n' +
 								chalk.yellow('Note: This command will:') +
 								'\n' +
 								'  1. Look for a PRD file at scripts/prd.txt by default\n' +
@@ -604,11 +761,19 @@ function registerCommands(programInstance) {
 				if (append) {
 					console.log(chalk.blue('Appending to existing tasks...'));
 				}
+				if (research) {
+					console.log(
+						chalk.blue(
+							'Using Perplexity AI for research-backed task generation'
+						)
+					);
+				}
 
-				spinner = ora('Parsing PRD and generating tasks...').start();
+				spinner = ora('Parsing PRD and generating tasks...\n').start();
 				await parsePRD(inputFile, outputPath, numTasks, {
 					append: useAppend,
-					useForce
+					force: useForce,
+					research: research
 				});
 				spinner.succeed('Tasks generated successfully!');
 			} catch (error) {
@@ -1030,6 +1195,8 @@ function registerCommands(programInstance) {
 	// set-status command
 	programInstance
 		.command('set-status')
+		.alias('mark')
+		.alias('set')
 		.description('Set the status of a task')
 		.option(
 			'-i, --id <id>',
@@ -1143,12 +1310,6 @@ function registerCommands(programInstance) {
 						{} // Pass empty context for CLI calls
 						// outputFormat defaults to 'text' in expandAllTasks for CLI
 					);
-					// Optional: Display summary from result
-					console.log(chalk.green(`Expansion Summary:`));
-					console.log(chalk.green(` - Attempted: ${result.tasksToExpand}`));
-					console.log(chalk.green(` - Expanded:  ${result.expandedCount}`));
-					console.log(chalk.yellow(` - Skipped:   ${result.skippedCount}`));
-					console.log(chalk.red(` - Failed:    ${result.failedCount}`));
 				} catch (error) {
 					console.error(
 						chalk.red(`Error expanding all tasks: ${error.message}`)
@@ -1216,6 +1377,12 @@ function registerCommands(programInstance) {
 			'-r, --research',
 			'Use Perplexity AI for research-backed complexity analysis'
 		)
+		.option(
+			'-i, --id <ids>',
+			'Comma-separated list of specific task IDs to analyze (e.g., "1,3,5")'
+		)
+		.option('--from <id>', 'Starting task ID in a range to analyze')
+		.option('--to <id>', 'Ending task ID in a range to analyze')
 		.action(async (options) => {
 			const tasksPath = options.file || 'tasks/tasks.json';
 			const outputPath = options.output;
@@ -1226,6 +1393,16 @@ function registerCommands(programInstance) {
 			console.log(chalk.blue(`Analyzing task complexity from: ${tasksPath}`));
 			console.log(chalk.blue(`Output report will be saved to: ${outputPath}`));
 
+			if (options.id) {
+				console.log(chalk.blue(`Analyzing specific task IDs: ${options.id}`));
+			} else if (options.from || options.to) {
+				const fromStr = options.from ? options.from : 'first';
+				const toStr = options.to ? options.to : 'last';
+				console.log(
+					chalk.blue(`Analyzing tasks in range: ${fromStr} to ${toStr}`)
+				);
+			}
+
 			if (useResearch) {
 				console.log(
 					chalk.blue(
@@ -1278,7 +1455,7 @@ function registerCommands(programInstance) {
 	// add-task command
 	programInstance
 		.command('add-task')
-		.description('Add a new task using AI or manual input')
+		.description('Add a new task using AI, optionally providing manual details')
 		.option('-f, --file <file>', 'Path to the tasks file', 'tasks/tasks.json')
 		.option(
 			'-p, --prompt <prompt>',
@@ -1319,74 +1496,70 @@ function registerCommands(programInstance) {
 				process.exit(1);
 			}
 
+			const tasksPath =
+				options.file ||
+				path.join(findProjectRoot() || '.', 'tasks', 'tasks.json') || // Ensure tasksPath is also relative to a found root or current dir
+				'tasks/tasks.json';
+
+			// Correctly determine projectRoot
+			const projectRoot = findProjectRoot();
+
+			let manualTaskData = null;
+			if (isManualCreation) {
+				manualTaskData = {
+					title: options.title,
+					description: options.description,
+					details: options.details || '',
+					testStrategy: options.testStrategy || ''
+				};
+				// Restore specific logging for manual creation
+				console.log(
+					chalk.blue(`Creating task manually with title: "${options.title}"`)
+				);
+			} else {
+				// Restore specific logging for AI creation
+				console.log(
+					chalk.blue(`Creating task with AI using prompt: "${options.prompt}"`)
+				);
+			}
+
+			// Log dependencies and priority if provided (restored)
+			const dependenciesArray = options.dependencies
+				? options.dependencies.split(',').map((id) => id.trim())
+				: [];
+			if (dependenciesArray.length > 0) {
+				console.log(
+					chalk.blue(`Dependencies: [${dependenciesArray.join(', ')}]`)
+				);
+			}
+			if (options.priority) {
+				console.log(chalk.blue(`Priority: ${options.priority}`));
+			}
+
+			const context = {
+				projectRoot,
+				commandName: 'add-task',
+				outputType: 'cli'
+			};
+
 			try {
-				// Prepare dependencies if provided
+				const { newTaskId, telemetryData } = await addTask(
-				let dependencies = [];
+					tasksPath,
-				if (options.dependencies) {
+					options.prompt,
-					dependencies = options.dependencies
+					dependenciesArray,
-						.split(',')
-						.map((id) => parseInt(id.trim(), 10));
-				}
-
-				// Create manual task data if title and description are provided
-				let manualTaskData = null;
-				if (isManualCreation) {
-					manualTaskData = {
-						title: options.title,
-						description: options.description,
-						details: options.details || '',
-						testStrategy: options.testStrategy || ''
-					};
-
-					console.log(
-						chalk.blue(`Creating task manually with title: "${options.title}"`)
-					);
-					if (dependencies.length > 0) {
-						console.log(
-							chalk.blue(`Dependencies: [${dependencies.join(', ')}]`)
-						);
-					}
-					if (options.priority) {
-						console.log(chalk.blue(`Priority: ${options.priority}`));
-					}
-				} else {
-					console.log(
-						chalk.blue(
-							`Creating task with AI using prompt: "${options.prompt}"`
-						)
-					);
-					if (dependencies.length > 0) {
-						console.log(
-							chalk.blue(`Dependencies: [${dependencies.join(', ')}]`)
-						);
-					}
-					if (options.priority) {
-						console.log(chalk.blue(`Priority: ${options.priority}`));
-					}
-				}
-
-				// Pass mcpLog and session for MCP mode
-				const newTaskId = await addTask(
-					options.file,
-					options.prompt, // Pass prompt (will be null/undefined if not provided)
-					dependencies,
 					options.priority,
-					{
+					context,
-						// For CLI, session context isn't directly available like MCP
+					'text',
-						// We don't need to pass session here for CLI API key resolution
+					manualTaskData,
-						// as dotenv loads .env, and utils.resolveEnvVariable checks process.env
+					options.research
-					},
-					'text', // outputFormat
-					manualTaskData, // Pass the potentially created manualTaskData object
-					options.research || false // Pass the research flag value
 				);
 
-				console.log(chalk.green(`✓ Added new task #${newTaskId}`));
+				// addTask handles detailed CLI success logging AND telemetry display when outputFormat is 'text'
-				console.log(chalk.gray('Next: Complete this task or add more tasks'));
+				// No need to call displayAiUsageSummary here anymore.
 			} catch (error) {
 				console.error(chalk.red(`Error adding task: ${error.message}`));
-				if (error.stack && getDebugFlag()) {
+				if (error.details) {
-					console.error(error.stack);
+					console.error(chalk.red(error.details));
 				}
 				process.exit(1);
 			}
@@ -2093,7 +2266,7 @@ function registerCommands(programInstance) {
 					);
 
 					// Exit with error if any removals failed
-					if (successfulRemovals.length === 0) {
+					if (result.removedTasks.length === 0) {
 						process.exit(1);
 					}
 				}
@@ -2161,6 +2334,10 @@ function registerCommands(programInstance) {
 			'--ollama',
 			'Allow setting a custom Ollama model ID (use with --set-*) '
 		)
+		.option(
+			'--bedrock',
+			'Allow setting a custom Bedrock model ID (use with --set-*) '
+		)
 		.addHelpText(
 			'after',
 			`
@@ -2170,17 +2347,26 @@ Examples:
   $ task-master models --set-research sonar-pro       # Set research model
   $ task-master models --set-fallback claude-3-5-sonnet-20241022 # Set fallback
   $ task-master models --set-main my-custom-model --ollama  # Set custom Ollama model for main role
+  $ task-master models --set-main anthropic.claude-3-sonnet-20240229-v1:0 --bedrock # Set custom Bedrock model for main role
   $ task-master models --set-main some/other-model --openrouter # Set custom OpenRouter model for main role
   $ task-master models --setup                            # Run interactive setup`
 		)
 		.action(async (options) => {
-			const projectRoot = findProjectRoot(); // Find project root for context
+			const projectRoot = findProjectRoot();
-
+			if (!projectRoot) {
-			// Validate flags: cannot use both --openrouter and --ollama simultaneously
+				console.error(chalk.red('Error: Could not find project root.'));
-			if (options.openrouter && options.ollama) {
+				process.exit(1);
+			}
+			// Validate flags: cannot use multiple provider flags simultaneously
+			const providerFlags = [
+				options.openrouter,
+				options.ollama,
+				options.bedrock
+			].filter(Boolean).length;
+			if (providerFlags > 1) {
 				console.error(
 					chalk.red(
-						'Error: Cannot use both --openrouter and --ollama flags simultaneously.'
+						'Error: Cannot use multiple provider flags (--openrouter, --ollama, --bedrock) simultaneously.'
 					)
 				);
 				process.exit(1);
@@ -2220,7 +2406,9 @@ Examples:
 							? 'openrouter'
 							: options.ollama
 								? 'ollama'
-								: undefined
+								: options.bedrock
+									? 'bedrock'
+									: undefined
 					});
 					if (result.success) {
 						console.log(chalk.green(`✅ ${result.data.message}`));
@@ -2240,7 +2428,9 @@ Examples:
 							? 'openrouter'
 							: options.ollama
 								? 'ollama'
-								: undefined
+								: options.bedrock
+									? 'bedrock'
+									: undefined
 					});
 					if (result.success) {
 						console.log(chalk.green(`✅ ${result.data.message}`));
@@ -2262,7 +2452,9 @@ Examples:
 							? 'openrouter'
 							: options.ollama
 								? 'ollama'
-								: undefined
+								: options.bedrock
+									? 'bedrock'
+									: undefined
 					});
 					if (result.success) {
 						console.log(chalk.green(`✅ ${result.data.message}`));
@@ -2358,6 +2550,135 @@ Examples:
 			return; // Stop execution here
 		});
 
+	// move-task command
+	programInstance
+		.command('move')
+		.description('Move a task or subtask to a new position')
+		.option('-f, --file <file>', 'Path to the tasks file', 'tasks/tasks.json')
+		.option(
+			'--from <id>',
+			'ID of the task/subtask to move (e.g., "5" or "5.2"). Can be comma-separated to move multiple tasks (e.g., "5,6,7")'
+		)
+		.option(
+			'--to <id>',
+			'ID of the destination (e.g., "7" or "7.3"). Must match the number of source IDs if comma-separated'
+		)
+		.action(async (options) => {
+			const tasksPath = options.file;
+			const sourceId = options.from;
+			const destinationId = options.to;
+
+			if (!sourceId || !destinationId) {
+				console.error(
+					chalk.red('Error: Both --from and --to parameters are required')
+				);
+				console.log(
+					chalk.yellow(
+						'Usage: task-master move --from=<sourceId> --to=<destinationId>'
+					)
+				);
+				process.exit(1);
+			}
+
+			// Check if we're moving multiple tasks (comma-separated IDs)
+			const sourceIds = sourceId.split(',').map((id) => id.trim());
+			const destinationIds = destinationId.split(',').map((id) => id.trim());
+
+			// Validate that the number of source and destination IDs match
+			if (sourceIds.length !== destinationIds.length) {
+				console.error(
+					chalk.red(
+						'Error: The number of source and destination IDs must match'
+					)
+				);
+				console.log(
+					chalk.yellow('Example: task-master move --from=5,6,7 --to=10,11,12')
+				);
+				process.exit(1);
+			}
+
+			// If moving multiple tasks
+			if (sourceIds.length > 1) {
+				console.log(
+					chalk.blue(
+						`Moving multiple tasks: ${sourceIds.join(', ')} to ${destinationIds.join(', ')}...`
+					)
+				);
+
+				try {
+					// Read tasks data once to validate destination IDs
+					const tasksData = readJSON(tasksPath);
+					if (!tasksData || !tasksData.tasks) {
+						console.error(
+							chalk.red(`Error: Invalid or missing tasks file at ${tasksPath}`)
+						);
+						process.exit(1);
+					}
+
+					// Move tasks one by one
+					for (let i = 0; i < sourceIds.length; i++) {
+						const fromId = sourceIds[i];
+						const toId = destinationIds[i];
+
+						// Skip if source and destination are the same
+						if (fromId === toId) {
+							console.log(
+								chalk.yellow(`Skipping ${fromId} -> ${toId} (same ID)`)
+							);
+							continue;
+						}
+
+						console.log(
+							chalk.blue(`Moving task/subtask ${fromId} to ${toId}...`)
+						);
+						try {
+							await moveTask(
+								tasksPath,
+								fromId,
+								toId,
+								i === sourceIds.length - 1
+							);
+							console.log(
+								chalk.green(
+									`✓ Successfully moved task/subtask ${fromId} to ${toId}`
+								)
+							);
+						} catch (error) {
+							console.error(
+								chalk.red(`Error moving ${fromId} to ${toId}: ${error.message}`)
+							);
+							// Continue with the next task rather than exiting
+						}
+					}
+				} catch (error) {
+					console.error(chalk.red(`Error: ${error.message}`));
+					process.exit(1);
+				}
+			} else {
+				// Moving a single task (existing logic)
+				console.log(
+					chalk.blue(`Moving task/subtask ${sourceId} to ${destinationId}...`)
+				);
+
+				try {
+					const result = await moveTask(
+						tasksPath,
+						sourceId,
+						destinationId,
+						true
+					);
+					console.log(
+						chalk.green(
+							`✓ Successfully moved task/subtask ${sourceId} to ${destinationId}`
+						)
+					);
+				} catch (error) {
+					console.error(chalk.red(`Error: ${error.message}`));
+					process.exit(1);
+				}
+			}
+		});
+
 	return programInstance;
 }
 

scripts/modules/config-manager.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
-import { log, resolveEnvVariable, findProjectRoot } from './utils.js';
+import { log, findProjectRoot, resolveEnvVariable } from './utils.js';
 
 // Calculate __dirname in ESM
 const __filename = fileURLToPath(import.meta.url);
@@ -61,7 +61,7 @@ const DEFAULTS = {
 		defaultSubtasks: 5,
 		defaultPriority: 'medium',
 		projectName: 'Task Master',
-		ollamaBaseUrl: 'http://localhost:11434/api'
+		ollamaBaseURL: 'http://localhost:11434/api'
 	}
 };
 
@@ -361,9 +361,34 @@ function getProjectName(explicitRoot = null) {
 	return getGlobalConfig(explicitRoot).projectName;
 }
 
-function getOllamaBaseUrl(explicitRoot = null) {
+function getOllamaBaseURL(explicitRoot = null) {
 	// Directly return value from config
-	return getGlobalConfig(explicitRoot).ollamaBaseUrl;
+	return getGlobalConfig(explicitRoot).ollamaBaseURL;
+}
+
+function getAzureBaseURL(explicitRoot = null) {
+	// Directly return value from config
+	return getGlobalConfig(explicitRoot).azureBaseURL;
+}
+
+/**
+ * Gets the Google Cloud project ID for Vertex AI from configuration
+ * @param {string|null} explicitRoot - Optional explicit path to the project root.
+ * @returns {string|null} The project ID or null if not configured
+ */
+function getVertexProjectId(explicitRoot = null) {
+	// Return value from config
+	return getGlobalConfig(explicitRoot).vertexProjectId;
+}
+
+/**
+ * Gets the Google Cloud location for Vertex AI from configuration
+ * @param {string|null} explicitRoot - Optional explicit path to the project root.
+ * @returns {string} The location or default value of "us-central1"
+ */
+function getVertexLocation(explicitRoot = null) {
+	// Return value from config or default
+	return getGlobalConfig(explicitRoot).vertexLocation || 'us-central1';
 }
 
 /**
@@ -450,7 +475,8 @@ function isApiKeySet(providerName, session = null, projectRoot = null) {
 		mistral: 'MISTRAL_API_KEY',
 		azure: 'AZURE_OPENAI_API_KEY',
 		openrouter: 'OPENROUTER_API_KEY',
-		xai: 'XAI_API_KEY'
+		xai: 'XAI_API_KEY',
+		vertex: 'GOOGLE_API_KEY' // Vertex uses the same key as Google
 		// Add other providers as needed
 	};
 
@@ -542,6 +568,10 @@ function getMcpApiKeyStatus(providerName, projectRoot = null) {
 				apiKeyToCheck = mcpEnv.AZURE_OPENAI_API_KEY;
 				placeholderValue = 'YOUR_AZURE_OPENAI_API_KEY_HERE';
 				break;
+			case 'vertex':
+				apiKeyToCheck = mcpEnv.GOOGLE_API_KEY; // Vertex uses Google API key
+				placeholderValue = 'YOUR_GOOGLE_API_KEY_HERE';
+				break;
 			default:
 				return false; // Unknown provider
 		}
@@ -669,6 +699,34 @@ function isConfigFilePresent(explicitRoot = null) {
 	return fs.existsSync(configPath);
 }
 
+/**
+ * Gets the user ID from the configuration.
+ * @param {string|null} explicitRoot - Optional explicit path to the project root.
+ * @returns {string|null} The user ID or null if not found.
+ */
+function getUserId(explicitRoot = null) {
+	const config = getConfig(explicitRoot);
+	if (!config.global) {
+		config.global = {}; // Ensure global object exists
+	}
+	if (!config.global.userId) {
+		config.global.userId = '1234567890';
+		// Attempt to write the updated config.
+		// It's important that writeConfig correctly resolves the path
+		// using explicitRoot, similar to how getConfig does.
+		const success = writeConfig(config, explicitRoot);
+		if (!success) {
+			// Log an error or handle the failure to write,
+			// though for now, we'll proceed with the in-memory default.
+			log(
+				'warning',
+				'Failed to write updated configuration with new userId. Please let the developers know.'
+			);
+		}
+	}
+	return config.global.userId;
+}
+
 /**
  * Gets a list of all provider names defined in the MODEL_MAP.
  * @returns {string[]} An array of provider names.
@@ -679,8 +737,8 @@ function getAllProviders() {
 
 function getBaseUrlForRole(role, explicitRoot = null) {
 	const roleConfig = getModelConfigForRole(role, explicitRoot);
-	return roleConfig && typeof roleConfig.baseUrl === 'string'
+	return roleConfig && typeof roleConfig.baseURL === 'string'
-		? roleConfig.baseUrl
+		? roleConfig.baseURL
 		: undefined;
 }
 
@@ -688,8 +746,8 @@ export {
 	// Core config access
 	getConfig,
 	writeConfig,
-	ConfigurationError, // Export custom error type
+	ConfigurationError,
-	isConfigFilePresent, // Add the new function export
+	isConfigFilePresent,
 
 	// Validation
 	validateProvider,
@@ -720,13 +778,16 @@ export {
 	getDefaultSubtasks,
 	getDefaultPriority,
 	getProjectName,
-	getOllamaBaseUrl,
+	getOllamaBaseURL,
+	getAzureBaseURL,
 	getParametersForRole,
-
+	getUserId,
 	// API Key Checkers (still relevant)
 	isApiKeySet,
 	getMcpApiKeyStatus,
 
 	// ADD: Function to get all provider names
-	getAllProviders
+	getAllProviders,
+	getVertexProjectId,
+	getVertexLocation
 };

scripts/modules/supported-models.json

@@ -1,5 +1,19 @@
 {
 	"anthropic": [
+		{
+			"id": "claude-sonnet-4-20250514",
+			"swe_score": 0.727,
+			"cost_per_1m_tokens": { "input": 3.0, "output": 15.0 },
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 64000
+		},
+		{
+			"id": "claude-opus-4-20250514",
+			"swe_score": 0.725,
+			"cost_per_1m_tokens": { "input": 15.0, "output": 75.0 },
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 32000
+		},
 		{
 			"id": "claude-3-7-sonnet-20250219",
 			"swe_score": 0.623,
@@ -99,34 +113,39 @@
 	],
 	"google": [
 		{
-			"id": "gemini-2.5-pro-exp-03-25",
+			"id": "gemini-2.5-pro-preview-05-06",
 			"swe_score": 0.638,
 			"cost_per_1m_tokens": null,
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 1048000
+		},
+		{
+			"id": "gemini-2.5-pro-preview-03-25",
+			"swe_score": 0.638,
+			"cost_per_1m_tokens": null,
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 1048000
 		},
 		{
 			"id": "gemini-2.5-flash-preview-04-17",
 			"swe_score": 0,
 			"cost_per_1m_tokens": null,
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 1048000
 		},
 		{
 			"id": "gemini-2.0-flash",
 			"swe_score": 0.754,
 			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 1048000
 		},
 		{
-			"id": "gemini-2.0-flash-thinking-experimental",
+			"id": "gemini-2.0-flash-lite",
-			"swe_score": 0.754,
-			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
-			"allowed_roles": ["main", "fallback"]
-		},
-		{
-			"id": "gemini-2.0-pro",
 			"swe_score": 0,
 			"cost_per_1m_tokens": null,
-			"allowed_roles": ["main", "fallback"]
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 1048000
 		}
 	],
 	"perplexity": [
@@ -186,43 +205,43 @@
 	],
 	"ollama": [
 		{
-			"id": "gemma3:27b",
+			"id": "devstral:latest",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0, "output": 0 },
 			"allowed_roles": ["main", "fallback"]
 		},
 		{
-			"id": "gemma3:12b",
+			"id": "qwen3:latest",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0, "output": 0 },
 			"allowed_roles": ["main", "fallback"]
 		},
 		{
-			"id": "qwq",
+			"id": "qwen3:14b",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0, "output": 0 },
 			"allowed_roles": ["main", "fallback"]
 		},
 		{
-			"id": "deepseek-r1",
+			"id": "qwen3:32b",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0, "output": 0 },
 			"allowed_roles": ["main", "fallback"]
 		},
 		{
-			"id": "mistral-small3.1",
+			"id": "mistral-small3.1:latest",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0, "output": 0 },
 			"allowed_roles": ["main", "fallback"]
 		},
 		{
-			"id": "llama3.3",
+			"id": "llama3.3:latest",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0, "output": 0 },
 			"allowed_roles": ["main", "fallback"]
 		},
 		{
-			"id": "phi4",
+			"id": "phi4:latest",
 			"swe_score": 0,
 			"cost_per_1m_tokens": { "input": 0, "output": 0 },
 			"allowed_roles": ["main", "fallback"]
@@ -230,9 +249,16 @@
 	],
 	"openrouter": [
 		{
-			"id": "google/gemini-2.0-flash-001",
+			"id": "google/gemini-2.5-flash-preview-05-20",
 			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0.1, "output": 0.4 },
+			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 1048576
+		},
+		{
+			"id": "google/gemini-2.5-flash-preview-05-20:thinking",
+			"swe_score": 0,
+			"cost_per_1m_tokens": { "input": 0.15, "output": 3.5 },
 			"allowed_roles": ["main", "fallback"],
 			"max_tokens": 1048576
 		},
@@ -258,40 +284,25 @@
 			"max_tokens": 64000
 		},
 		{
-			"id": "deepseek/deepseek-r1:free",
+			"id": "openai/gpt-4.1",
 			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0, "output": 0 },
+			"cost_per_1m_tokens": { "input": 2, "output": 8 },
 			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 163840
+			"max_tokens": 1000000
 		},
-
 		{
-			"id": "microsoft/mai-ds-r1:free",
+			"id": "openai/gpt-4.1-mini",
 			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0, "output": 0 },
+			"cost_per_1m_tokens": { "input": 0.4, "output": 1.6 },
 			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 163840
+			"max_tokens": 1000000
 		},
 		{
-			"id": "google/gemini-2.5-pro-preview-03-25",
+			"id": "openai/gpt-4.1-nano",
 			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 1.25, "output": 10 },
+			"cost_per_1m_tokens": { "input": 0.1, "output": 0.4 },
 			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 65535
+			"max_tokens": 1000000
-		},
-		{
-			"id": "google/gemini-2.5-flash-preview",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
-			"allowed_roles": ["main"],
-			"max_tokens": 65535
-		},
-		{
-			"id": "google/gemini-2.5-flash-preview:thinking",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0.15, "output": 3.5 },
-			"allowed_roles": ["main"],
-			"max_tokens": 65535
 		},
 		{
 			"id": "openai/o3",
@@ -300,6 +311,20 @@
 			"allowed_roles": ["main", "fallback"],
 			"max_tokens": 200000
 		},
+		{
+			"id": "openai/codex-mini",
+			"swe_score": 0,
+			"cost_per_1m_tokens": { "input": 1.5, "output": 6 },
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 100000
+		},
+		{
+			"id": "openai/gpt-4o-mini",
+			"swe_score": 0,
+			"cost_per_1m_tokens": { "input": 0.15, "output": 0.6 },
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 100000
+		},
 		{
 			"id": "openai/o4-mini",
 			"swe_score": 0.45,
@@ -329,46 +354,18 @@
 			"max_tokens": 1048576
 		},
 		{
-			"id": "google/gemma-3-12b-it:free",
+			"id": "meta-llama/llama-4-maverick",
 			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0, "output": 0 },
+			"cost_per_1m_tokens": { "input": 0.18, "output": 0.6 },
 			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 131072
+			"max_tokens": 1000000
 		},
 		{
-			"id": "google/gemma-3-12b-it",
+			"id": "meta-llama/llama-4-scout",
 			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 50, "output": 100 },
+			"cost_per_1m_tokens": { "input": 0.08, "output": 0.3 },
 			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 131072
+			"max_tokens": 1000000
-		},
-		{
-			"id": "google/gemma-3-27b-it:free",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0, "output": 0 },
-			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 96000
-		},
-		{
-			"id": "google/gemma-3-27b-it",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 100, "output": 200 },
-			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 131072
-		},
-		{
-			"id": "qwen/qwq-32b:free",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 0, "output": 0 },
-			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 40000
-		},
-		{
-			"id": "qwen/qwq-32b",
-			"swe_score": 0,
-			"cost_per_1m_tokens": { "input": 150, "output": 200 },
-			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 131072
 		},
 		{
 			"id": "qwen/qwen-max",
@@ -384,6 +381,13 @@
 			"allowed_roles": ["main", "fallback"],
 			"max_tokens": 1000000
 		},
+		{
+			"id": "qwen/qwen3-235b-a22b",
+			"swe_score": 0,
+			"cost_per_1m_tokens": { "input": 0.14, "output": 2 },
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 24000
+		},
 		{
 			"id": "mistralai/mistral-small-3.1-24b-instruct:free",
 			"swe_score": 0,
@@ -398,6 +402,20 @@
 			"allowed_roles": ["main", "fallback"],
 			"max_tokens": 128000
 		},
+		{
+			"id": "mistralai/devstral-small",
+			"swe_score": 0,
+			"cost_per_1m_tokens": { "input": 0.1, "output": 0.3 },
+			"allowed_roles": ["main"],
+			"max_tokens": 110000
+		},
+		{
+			"id": "mistralai/mistral-nemo",
+			"swe_score": 0,
+			"cost_per_1m_tokens": { "input": 0.03, "output": 0.07 },
+			"allowed_roles": ["main", "fallback"],
+			"max_tokens": 100000
+		},
 		{
 			"id": "thudm/glm-4-32b:free",
 			"swe_score": 0,

scripts/modules/task-manager.js

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

scripts/modules/task-manager/analyze-task-complexity.js

@@ -1,10 +1,15 @@
 import chalk from 'chalk';
 import boxen from 'boxen';
 import readline from 'readline';
+import fs from 'fs';
 
 import { log, readJSON, writeJSON, isSilentMode } from '../utils.js';
 
-import { startLoadingIndicator, stopLoadingIndicator } from '../ui.js';
+import {
+	startLoadingIndicator,
+	stopLoadingIndicator,
+	displayAiUsageSummary
+} from '../ui.js';
 
 import { generateTextService } from '../ai-services-unified.js';
 
@@ -47,6 +52,9 @@ Do not include any explanatory text, markdown formatting, or code block markers
  * @param {string|number} [options.threshold] - Complexity threshold
  * @param {boolean} [options.research] - Use research role
  * @param {string} [options.projectRoot] - Project root path (for MCP/env fallback).
+ * @param {string} [options.id] - Comma-separated list of task IDs to analyze specifically
+ * @param {number} [options.from] - Starting task ID in a range to analyze
+ * @param {number} [options.to] - Ending task ID in a range to analyze
  * @param {Object} [options._filteredTasksData] - Pre-filtered task data (internal use)
  * @param {number} [options._originalTaskCount] - Original task count (internal use)
  * @param {Object} context - Context object, potentially containing session and mcpLog
@@ -61,6 +69,15 @@ async function analyzeTaskComplexity(options, context = {}) {
 	const thresholdScore = parseFloat(options.threshold || '5');
 	const useResearch = options.research || false;
 	const projectRoot = options.projectRoot;
+	// New parameters for task ID filtering
+	const specificIds = options.id
+		? options.id
+				.split(',')
+				.map((id) => parseInt(id.trim(), 10))
+				.filter((id) => !isNaN(id))
+		: null;
+	const fromId = options.from !== undefined ? parseInt(options.from, 10) : null;
+	const toId = options.to !== undefined ? parseInt(options.to, 10) : null;
 
 	const outputFormat = mcpLog ? 'json' : 'text';
 
@@ -84,13 +101,14 @@ async function analyzeTaskComplexity(options, context = {}) {
 		reportLog(`Reading tasks from ${tasksPath}...`, 'info');
 		let tasksData;
 		let originalTaskCount = 0;
+		let originalData = null;
 
 		if (options._filteredTasksData) {
 			tasksData = options._filteredTasksData;
 			originalTaskCount = options._originalTaskCount || tasksData.tasks.length;
 			if (!options._originalTaskCount) {
 				try {
-					const originalData = readJSON(tasksPath);
+					originalData = readJSON(tasksPath);
 					if (originalData && originalData.tasks) {
 						originalTaskCount = originalData.tasks.length;
 					}
@@ -99,22 +117,80 @@ async function analyzeTaskComplexity(options, context = {}) {
 				}
 			}
 		} else {
-			tasksData = readJSON(tasksPath);
+			originalData = readJSON(tasksPath);
 			if (
-				!tasksData ||
+				!originalData ||
-				!tasksData.tasks ||
+				!originalData.tasks ||
-				!Array.isArray(tasksData.tasks) ||
+				!Array.isArray(originalData.tasks) ||
-				tasksData.tasks.length === 0
+				originalData.tasks.length === 0
 			) {
 				throw new Error('No tasks found in the tasks file');
 			}
-			originalTaskCount = tasksData.tasks.length;
+			originalTaskCount = originalData.tasks.length;
+
+			// Filter tasks based on active status
 			const activeStatuses = ['pending', 'blocked', 'in-progress'];
-			const filteredTasks = tasksData.tasks.filter((task) =>
+			let filteredTasks = originalData.tasks.filter((task) =>
 				activeStatuses.includes(task.status?.toLowerCase() || 'pending')
 			);
+
+			// Apply ID filtering if specified
+			if (specificIds && specificIds.length > 0) {
+				reportLog(
+					`Filtering tasks by specific IDs: ${specificIds.join(', ')}`,
+					'info'
+				);
+				filteredTasks = filteredTasks.filter((task) =>
+					specificIds.includes(task.id)
+				);
+
+				if (outputFormat === 'text') {
+					if (filteredTasks.length === 0 && specificIds.length > 0) {
+						console.log(
+							chalk.yellow(
+								`Warning: No active tasks found with IDs: ${specificIds.join(', ')}`
+							)
+						);
+					} else if (filteredTasks.length < specificIds.length) {
+						const foundIds = filteredTasks.map((t) => t.id);
+						const missingIds = specificIds.filter(
+							(id) => !foundIds.includes(id)
+						);
+						console.log(
+							chalk.yellow(
+								`Warning: Some requested task IDs were not found or are not active: ${missingIds.join(', ')}`
+							)
+						);
+					}
+				}
+			}
+			// Apply range filtering if specified
+			else if (fromId !== null || toId !== null) {
+				const effectiveFromId = fromId !== null ? fromId : 1;
+				const effectiveToId =
+					toId !== null
+						? toId
+						: Math.max(...originalData.tasks.map((t) => t.id));
+
+				reportLog(
+					`Filtering tasks by ID range: ${effectiveFromId} to ${effectiveToId}`,
+					'info'
+				);
+				filteredTasks = filteredTasks.filter(
+					(task) => task.id >= effectiveFromId && task.id <= effectiveToId
+				);
+
+				if (outputFormat === 'text' && filteredTasks.length === 0) {
+					console.log(
+						chalk.yellow(
+							`Warning: No active tasks found in range: ${effectiveFromId}-${effectiveToId}`
+						)
+					);
+				}
+			}
+
 			tasksData = {
-				...tasksData,
+				...originalData,
 				tasks: filteredTasks,
 				_originalTaskCount: originalTaskCount
 			};
@@ -125,7 +201,18 @@ async function analyzeTaskComplexity(options, context = {}) {
 			`Found ${originalTaskCount} total tasks in the task file.`,
 			'info'
 		);
-		if (skippedCount > 0) {
+
+		// Updated messaging to reflect filtering logic
+		if (specificIds || fromId !== null || toId !== null) {
+			const filterMsg = specificIds
+				? `Analyzing ${tasksData.tasks.length} tasks with specific IDs: ${specificIds.join(', ')}`
+				: `Analyzing ${tasksData.tasks.length} tasks in range: ${fromId || 1} to ${toId || 'end'}`;
+
+			reportLog(filterMsg, 'info');
+			if (outputFormat === 'text') {
+				console.log(chalk.blue(filterMsg));
+			}
+		} else if (skippedCount > 0) {
 			const skipMessage = `Skipping ${skippedCount} tasks marked as done/cancelled/deferred. Analyzing ${tasksData.tasks.length} active tasks.`;
 			reportLog(skipMessage, 'info');
 			if (outputFormat === 'text') {
@@ -133,7 +220,59 @@ async function analyzeTaskComplexity(options, context = {}) {
 			}
 		}
 
+		// Check for existing report before doing analysis
+		let existingReport = null;
+		let existingAnalysisMap = new Map(); // For quick lookups by task ID
+		try {
+			if (fs.existsSync(outputPath)) {
+				existingReport = readJSON(outputPath);
+				reportLog(`Found existing complexity report at ${outputPath}`, 'info');
+
+				if (
+					existingReport &&
+					existingReport.complexityAnalysis &&
+					Array.isArray(existingReport.complexityAnalysis)
+				) {
+					// Create lookup map of existing analysis entries
+					existingReport.complexityAnalysis.forEach((item) => {
+						existingAnalysisMap.set(item.taskId, item);
+					});
+					reportLog(
+						`Existing report contains ${existingReport.complexityAnalysis.length} task analyses`,
+						'info'
+					);
+				}
+			}
+		} catch (readError) {
+			reportLog(
+				`Warning: Could not read existing report: ${readError.message}`,
+				'warn'
+			);
+			existingReport = null;
+			existingAnalysisMap.clear();
+		}
+
 		if (tasksData.tasks.length === 0) {
+			// If using ID filtering but no matching tasks, return existing report or empty
+			if (existingReport && (specificIds || fromId !== null || toId !== null)) {
+				reportLog(
+					`No matching tasks found for analysis. Keeping existing report.`,
+					'info'
+				);
+				if (outputFormat === 'text') {
+					console.log(
+						chalk.yellow(
+							`No matching tasks found for analysis. Keeping existing report.`
+						)
+					);
+				}
+				return {
+					report: existingReport,
+					telemetryData: null
+				};
+			}
+
+			// Otherwise create empty report
 			const emptyReport = {
 				meta: {
 					generatedAt: new Date().toISOString(),
@@ -142,9 +281,9 @@ async function analyzeTaskComplexity(options, context = {}) {
 					projectName: getProjectName(session),
 					usedResearch: useResearch
 				},
-				complexityAnalysis: []
+				complexityAnalysis: existingReport?.complexityAnalysis || []
 			};
-			reportLog(`Writing empty complexity report to ${outputPath}...`, 'info');
+			reportLog(`Writing complexity report to ${outputPath}...`, 'info');
 			writeJSON(outputPath, emptyReport);
 			reportLog(
 				`Task complexity analysis complete. Report written to ${outputPath}`,
@@ -192,39 +331,40 @@ async function analyzeTaskComplexity(options, context = {}) {
 					)
 				);
 			}
-			return emptyReport;
+			return {
+				report: emptyReport,
+				telemetryData: null
+			};
 		}
 
+		// Continue with regular analysis path
 		const prompt = generateInternalComplexityAnalysisPrompt(tasksData);
-		// System prompt remains simple for text generation
 		const systemPrompt =
 			'You are an expert software architect and project manager analyzing task complexity. Respond only with the requested valid JSON array.';
 
 		let loadingIndicator = null;
 		if (outputFormat === 'text') {
-			loadingIndicator = startLoadingIndicator('Calling AI service...');
+			loadingIndicator = startLoadingIndicator(
+				`${useResearch ? 'Researching' : 'Analyzing'} the complexity of your tasks with AI...\n`
+			);
 		}
 
-		let fullResponse = ''; // To store the raw text response
+		let aiServiceResponse = null;
+		let complexityAnalysis = null;
 
 		try {
 			const role = useResearch ? 'research' : 'main';
-			reportLog(`Using AI service with role: ${role}`, 'info');
 
-			fullResponse = await generateTextService({
+			aiServiceResponse = await generateTextService({
 				prompt,
 				systemPrompt,
 				role,
 				session,
-				projectRoot
+				projectRoot,
+				commandName: 'analyze-complexity',
+				outputType: mcpLog ? 'mcp' : 'cli'
 			});
 
-			reportLog(
-				'Successfully received text response via AI service',
-				'success'
-			);
-
-			// --- Stop Loading Indicator (Unchanged) ---
 			if (loadingIndicator) {
 				stopLoadingIndicator(loadingIndicator);
 				loadingIndicator = null;
@@ -236,26 +376,18 @@ async function analyzeTaskComplexity(options, context = {}) {
 					chalk.green('AI service call complete. Parsing response...')
 				);
 			}
-			// --- End Stop Loading Indicator ---
 
-			// --- Re-introduce Manual JSON Parsing & Cleanup ---
 			reportLog(`Parsing complexity analysis from text response...`, 'info');
-			let complexityAnalysis;
 			try {
-				let cleanedResponse = fullResponse;
+				let cleanedResponse = aiServiceResponse.mainResult;
-				// Basic trim first
 				cleanedResponse = cleanedResponse.trim();
 
-				// Remove potential markdown code block fences
 				const codeBlockMatch = cleanedResponse.match(
 					/```(?:json)?\s*([\s\S]*?)\s*```/
 				);
 				if (codeBlockMatch) {
-					cleanedResponse = codeBlockMatch[1].trim(); // Trim content inside block
+					cleanedResponse = codeBlockMatch[1].trim();
-					reportLog('Extracted JSON from code block', 'info');
 				} else {
-					// If no code block, ensure it starts with '[' and ends with ']'
-					// This is less robust but a common fallback
 					const firstBracket = cleanedResponse.indexOf('[');
 					const lastBracket = cleanedResponse.lastIndexOf(']');
 					if (firstBracket !== -1 && lastBracket > firstBracket) {
@@ -263,13 +395,11 @@ async function analyzeTaskComplexity(options, context = {}) {
 							firstBracket,
 							lastBracket + 1
 						);
-						reportLog('Extracted content between first [ and last ]', 'info');
 					} else {
 						reportLog(
 							'Warning: Response does not appear to be a JSON array.',
 							'warn'
 						);
-						// Keep going, maybe JSON.parse can handle it or will fail informatively
 					}
 				}
 
@@ -283,48 +413,23 @@ async function analyzeTaskComplexity(options, context = {}) {
 					);
 				}
 
-				try {
+				complexityAnalysis = JSON.parse(cleanedResponse);
-					complexityAnalysis = JSON.parse(cleanedResponse);
+			} catch (parseError) {
-				} catch (jsonError) {
+				if (loadingIndicator) stopLoadingIndicator(loadingIndicator);
-					reportLog(
-						'Initial JSON parsing failed. Raw response might be malformed.',
-						'error'
-					);
-					reportLog(`Original JSON Error: ${jsonError.message}`, 'error');
-					if (outputFormat === 'text' && getDebugFlag(session)) {
-						console.log(chalk.red('--- Start Raw Malformed Response ---'));
-						console.log(chalk.gray(fullResponse));
-						console.log(chalk.red('--- End Raw Malformed Response ---'));
-					}
-					// Re-throw the specific JSON parsing error
-					throw new Error(
-						`Failed to parse JSON response: ${jsonError.message}`
-					);
-				}
-
-				// Ensure it's an array after parsing
-				if (!Array.isArray(complexityAnalysis)) {
-					throw new Error('Parsed response is not a valid JSON array.');
-				}
-			} catch (error) {
-				// Catch errors specifically from the parsing/cleanup block
-				if (loadingIndicator) stopLoadingIndicator(loadingIndicator); // Ensure indicator stops
 				reportLog(
-					`Error parsing complexity analysis JSON: ${error.message}`,
+					`Error parsing complexity analysis JSON: ${parseError.message}`,
 					'error'
 				);
 				if (outputFormat === 'text') {
 					console.error(
 						chalk.red(
-							`Error parsing complexity analysis JSON: ${error.message}`
+							`Error parsing complexity analysis JSON: ${parseError.message}`
 						)
 					);
 				}
-				throw error; // Re-throw parsing error
+				throw parseError;
 			}
-			// --- End Manual JSON Parsing & Cleanup ---
 
-			// --- Post-processing (Missing Task Check) - (Unchanged) ---
 			const taskIds = tasksData.tasks.map((t) => t.id);
 			const analysisTaskIds = complexityAnalysis.map((a) => a.taskId);
 			const missingTaskIds = taskIds.filter(
@@ -359,35 +464,64 @@ async function analyzeTaskComplexity(options, context = {}) {
 					}
 				}
 			}
-			// --- End Post-processing ---
 
-			// --- Report Creation & Writing (Unchanged) ---
+			// Merge with existing report
-			const finalReport = {
+			let finalComplexityAnalysis = [];
+
+			if (existingReport && Array.isArray(existingReport.complexityAnalysis)) {
+				// Create a map of task IDs that we just analyzed
+				const analyzedTaskIds = new Set(
+					complexityAnalysis.map((item) => item.taskId)
+				);
+
+				// Keep existing entries that weren't in this analysis run
+				const existingEntriesNotAnalyzed =
+					existingReport.complexityAnalysis.filter(
+						(item) => !analyzedTaskIds.has(item.taskId)
+					);
+
+				// Combine with new analysis
+				finalComplexityAnalysis = [
+					...existingEntriesNotAnalyzed,
+					...complexityAnalysis
+				];
+
+				reportLog(
+					`Merged ${complexityAnalysis.length} new analyses with ${existingEntriesNotAnalyzed.length} existing entries`,
+					'info'
+				);
+			} else {
+				// No existing report or invalid format, just use the new analysis
+				finalComplexityAnalysis = complexityAnalysis;
+			}
+
+			const report = {
 				meta: {
 					generatedAt: new Date().toISOString(),
 					tasksAnalyzed: tasksData.tasks.length,
+					totalTasks: originalTaskCount,
+					analysisCount: finalComplexityAnalysis.length,
 					thresholdScore: thresholdScore,
 					projectName: getProjectName(session),
 					usedResearch: useResearch
 				},
-				complexityAnalysis: complexityAnalysis
+				complexityAnalysis: finalComplexityAnalysis
 			};
 			reportLog(`Writing complexity report to ${outputPath}...`, 'info');
-			writeJSON(outputPath, finalReport);
+			writeJSON(outputPath, report);
 
 			reportLog(
 				`Task complexity analysis complete. Report written to ${outputPath}`,
 				'success'
 			);
-			// --- End Report Creation & Writing ---
 
-			// --- Display CLI Summary (Unchanged) ---
 			if (outputFormat === 'text') {
 				console.log(
 					chalk.green(
 						`Task complexity analysis complete. Report written to ${outputPath}`
 					)
 				);
+				// Calculate statistics specifically for this analysis run
 				const highComplexity = complexityAnalysis.filter(
 					(t) => t.complexityScore >= 8
 				).length;
@@ -399,18 +533,25 @@ async function analyzeTaskComplexity(options, context = {}) {
 				).length;
 				const totalAnalyzed = complexityAnalysis.length;
 
-				console.log('\nComplexity Analysis Summary:');
+				console.log('\nCurrent Analysis Summary:');
 				console.log('----------------------------');
-				console.log(
+				console.log(`Tasks analyzed in this run: ${totalAnalyzed}`);
-					`Active tasks sent for analysis: ${tasksData.tasks.length}`
-				);
-				console.log(`Tasks successfully analyzed: ${totalAnalyzed}`);
 				console.log(`High complexity tasks: ${highComplexity}`);
 				console.log(`Medium complexity tasks: ${mediumComplexity}`);
 				console.log(`Low complexity tasks: ${lowComplexity}`);
-				console.log(
+
-					`Sum verification: ${highComplexity + mediumComplexity + lowComplexity} (should equal ${totalAnalyzed})`
+				if (existingReport) {
-				);
+					console.log('\nUpdated Report Summary:');
+					console.log('----------------------------');
+					console.log(
+						`Total analyses in report: ${finalComplexityAnalysis.length}`
+					);
+					console.log(
+						`Analyses from previous runs: ${finalComplexityAnalysis.length - totalAnalyzed}`
+					);
+					console.log(`New/updated analyses: ${totalAnalyzed}`);
+				}
+
 				console.log(`Research-backed analysis: ${useResearch ? 'Yes' : 'No'}`);
 				console.log(
 					`\nSee ${outputPath} for the full report and expansion commands.`
@@ -435,23 +576,28 @@ async function analyzeTaskComplexity(options, context = {}) {
 				if (getDebugFlag(session)) {
 					console.debug(
 						chalk.gray(
-							`Final analysis object: ${JSON.stringify(finalReport, null, 2)}`
+							`Final analysis object: ${JSON.stringify(report, null, 2)}`
 						)
 					);
 				}
-			}
-			// --- End Display CLI Summary ---
 
-			return finalReport;
+				if (aiServiceResponse.telemetryData) {
-		} catch (error) {
+					displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli');
-			// Catches errors from generateTextService call
+				}
+			}
+
+			return {
+				report: report,
+				telemetryData: aiServiceResponse?.telemetryData
+			};
+		} catch (aiError) {
 			if (loadingIndicator) stopLoadingIndicator(loadingIndicator);
-			reportLog(`Error during AI service call: ${error.message}`, 'error');
+			reportLog(`Error during AI service call: ${aiError.message}`, 'error');
 			if (outputFormat === 'text') {
 				console.error(
-					chalk.red(`Error during AI service call: ${error.message}`)
+					chalk.red(`Error during AI service call: ${aiError.message}`)
 				);
-				if (error.message.includes('API key')) {
+				if (aiError.message.includes('API key')) {
 					console.log(
 						chalk.yellow(
 							'\nPlease ensure your API keys are correctly configured in .env or ~/.taskmaster/.env'
@@ -462,10 +608,9 @@ async function analyzeTaskComplexity(options, context = {}) {
 					);
 				}
 			}
-			throw error; // Re-throw AI service error
+			throw aiError;
 		}
 	} catch (error) {
-		// Catches general errors (file read, etc.)
 		reportLog(`Error analyzing task complexity: ${error.message}`, 'error');
 		if (outputFormat === 'text') {
 			console.error(

scripts/modules/task-manager/expand-all-tasks.js

@@ -1,7 +1,14 @@
 import { log, readJSON, isSilentMode } from '../utils.js';
-import { startLoadingIndicator, stopLoadingIndicator } from '../ui.js';
+import {
+	startLoadingIndicator,
+	stopLoadingIndicator,
+	displayAiUsageSummary
+} from '../ui.js';
 import expandTask from './expand-task.js';
 import { getDebugFlag } from '../config-manager.js';
+import { aggregateTelemetry } from '../utils.js';
+import chalk from 'chalk';
+import boxen from 'boxen';
 
 /**
  * Expand all eligible pending or in-progress tasks using the expandTask function.
@@ -14,7 +21,7 @@ import { getDebugFlag } from '../config-manager.js';
  * @param {Object} [context.session] - Session object from MCP.
  * @param {Object} [context.mcpLog] - MCP logger object.
  * @param {string} [outputFormat='text'] - Output format ('text' or 'json'). MCP calls should use 'json'.
- * @returns {Promise<{success: boolean, expandedCount: number, failedCount: number, skippedCount: number, tasksToExpand: number, message?: string}>} - Result summary.
+ * @returns {Promise<{success: boolean, expandedCount: number, failedCount: number, skippedCount: number, tasksToExpand: number, telemetryData: Array<Object>}>} - Result summary.
  */
 async function expandAllTasks(
 	tasksPath,
@@ -51,8 +58,8 @@ async function expandAllTasks(
 	let loadingIndicator = null;
 	let expandedCount = 0;
 	let failedCount = 0;
-	// No skipped count needed now as the filter handles it upfront
+	let tasksToExpandCount = 0;
-	let tasksToExpandCount = 0; // Renamed for clarity
+	const allTelemetryData = []; // Still collect individual data first
 
 	if (!isMCPCall && outputFormat === 'text') {
 		loadingIndicator = startLoadingIndicator(
@@ -90,6 +97,7 @@ async function expandAllTasks(
 				failedCount: 0,
 				skippedCount: 0,
 				tasksToExpand: 0,
+				telemetryData: allTelemetryData,
 				message: 'No tasks eligible for expansion.'
 			};
 			// --- End Fix ---
@@ -97,19 +105,6 @@ async function expandAllTasks(
 
 		// Iterate over the already filtered tasks
 		for (const task of tasksToExpand) {
-			// --- Remove Redundant Check ---
-			// The check below is no longer needed as the initial filter handles it
-			/*
-			if (task.subtasks && task.subtasks.length > 0 && !force) {
-				logger.info(
-					`Skipping task ${task.id}: Already has subtasks. Use --force to overwrite.`
-				);
-				skippedCount++;
-				continue;
-			}
-			*/
-			// --- End Removed Redundant Check ---
-
 			// Start indicator for individual task expansion in CLI mode
 			let taskIndicator = null;
 			if (!isMCPCall && outputFormat === 'text') {
@@ -117,17 +112,23 @@ async function expandAllTasks(
 			}
 
 			try {
-				// Call the refactored expandTask function
+				// Call the refactored expandTask function AND capture result
-				await expandTask(
+				const result = await expandTask(
 					tasksPath,
 					task.id,
-					numSubtasks, // Pass numSubtasks, expandTask handles defaults/complexity
+					numSubtasks,
 					useResearch,
 					additionalContext,
 					context, // Pass the whole context object { session, mcpLog }
-					force // Pass the force flag down
+					force
 				);
 				expandedCount++;
+
+				// Collect individual telemetry data
+				if (result && result.telemetryData) {
+					allTelemetryData.push(result.telemetryData);
+				}
+
 				if (taskIndicator) {
 					stopLoadingIndicator(taskIndicator, `Task ${task.id} expanded.`);
 				}
@@ -146,18 +147,48 @@ async function expandAllTasks(
 			}
 		}
 
-		// Log final summary (removed skipped count from message)
+		// --- AGGREGATION AND DISPLAY ---
 		logger.info(
 			`Expansion complete: ${expandedCount} expanded, ${failedCount} failed.`
 		);
 
-		// Return summary (skippedCount is now 0) - Add success: true here as well for consistency
+		// Aggregate the collected telemetry data
+		const aggregatedTelemetryData = aggregateTelemetry(
+			allTelemetryData,
+			'expand-all-tasks'
+		);
+
+		if (outputFormat === 'text') {
+			const summaryContent =
+				`${chalk.white.bold('Expansion Summary:')}\n\n` +
+				`${chalk.cyan('-')} Attempted: ${chalk.bold(tasksToExpandCount)}\n` +
+				`${chalk.green('-')} Expanded:  ${chalk.bold(expandedCount)}\n` +
+				// Skipped count is always 0 now due to pre-filtering
+				`${chalk.gray('-')} Skipped:   ${chalk.bold(0)}\n` +
+				`${chalk.red('-')} Failed:    ${chalk.bold(failedCount)}`;
+
+			console.log(
+				boxen(summaryContent, {
+					padding: 1,
+					margin: { top: 1 },
+					borderColor: failedCount > 0 ? 'red' : 'green', // Red if failures, green otherwise
+					borderStyle: 'round'
+				})
+			);
+		}
+
+		if (outputFormat === 'text' && aggregatedTelemetryData) {
+			displayAiUsageSummary(aggregatedTelemetryData, 'cli');
+		}
+
+		// Return summary including the AGGREGATED telemetry data
 		return {
-			success: true, // Indicate overall success
+			success: true,
 			expandedCount,
 			failedCount,
 			skippedCount: 0,
-			tasksToExpand: tasksToExpandCount
+			tasksToExpand: tasksToExpandCount,
+			telemetryData: aggregatedTelemetryData
 		};
 	} catch (error) {
 		if (loadingIndicator)

scripts/modules/task-manager/expand-task.js

@@ -4,7 +4,11 @@ import { z } from 'zod';
 
 import { log, readJSON, writeJSON, isSilentMode } from '../utils.js';
 
-import { startLoadingIndicator, stopLoadingIndicator } from '../ui.js';
+import {
+	startLoadingIndicator,
+	stopLoadingIndicator,
+	displayAiUsageSummary
+} from '../ui.js';
 
 import { generateTextService } from '../ai-services-unified.js';
 
@@ -142,7 +146,7 @@ function generateResearchUserPrompt(
       "id": <number>, // Sequential ID starting from ${nextSubtaskId}
       "title": "<string>",
       "description": "<string>",
-      "dependencies": [<number>], // e.g., [${nextSubtaskId + 1}]
+      "dependencies": [<number>], // e.g., [${nextSubtaskId + 1}]. If no dependencies, use an empty array [].
       "details": "<string>",
       "testStrategy": "<string>" // Optional
     },
@@ -162,6 +166,8 @@ ${contextPrompt}
 CRITICAL: Respond ONLY with a valid JSON object containing a single key "subtasks". The value must be an array of the generated subtasks, strictly matching this structure:
 ${schemaDescription}
 
+Important: For the 'dependencies' field, if a subtask has no dependencies, you MUST use an empty array, for example: "dependencies": []. Do not use null or omit the field.
+
 Do not include ANY explanatory text, markdown, or code block markers. Just the JSON object.`;
 }
 
@@ -182,77 +188,153 @@ function parseSubtasksFromText(
 	parentTaskId,
 	logger
 ) {
-	logger.info('Attempting to parse subtasks object from text response...');
+	if (typeof text !== 'string') {
-	if (!text || text.trim() === '') {
+		logger.error(
-		throw new Error('AI response text is empty.');
+			`AI response text is not a string. Received type: ${typeof text}, Value: ${text}`
+		);
+		throw new Error('AI response text is not a string.');
 	}
 
-	let cleanedResponse = text.trim();
+	if (!text || text.trim() === '') {
-	const originalResponseForDebug = cleanedResponse;
+		throw new Error('AI response text is empty after trimming.');
+	}
 
-	// 1. Extract from Markdown code block first
+	const originalTrimmedResponse = text.trim(); // Store the original trimmed response
-	const codeBlockMatch = cleanedResponse.match(
+	let jsonToParse = originalTrimmedResponse; // Initialize jsonToParse with it
-		/```(?:json)?\s*([\s\S]*?)\s*```/
+
+	logger.debug(
+		`Original AI Response for parsing (full length: ${jsonToParse.length}): ${jsonToParse.substring(0, 1000)}...`
 	);
-	if (codeBlockMatch) {
+
-		cleanedResponse = codeBlockMatch[1].trim();
+	// --- Pre-emptive cleanup for known AI JSON issues ---
-		logger.info('Extracted JSON content from Markdown code block.');
+	// Fix for "dependencies": , or "dependencies":,
-	} else {
+	if (jsonToParse.includes('"dependencies":')) {
-		// 2. If no code block, find first '{' and last '}' for the object
+		const malformedPattern = /"dependencies":\s*,/g;
-		const firstBrace = cleanedResponse.indexOf('{');
+		if (malformedPattern.test(jsonToParse)) {
-		const lastBrace = cleanedResponse.lastIndexOf('}');
+			logger.warn('Attempting to fix malformed "dependencies": , issue.');
-		if (firstBrace !== -1 && lastBrace > firstBrace) {
+			jsonToParse = jsonToParse.replace(
-			cleanedResponse = cleanedResponse.substring(firstBrace, lastBrace + 1);
+				malformedPattern,
-			logger.info('Extracted content between first { and last }.');
+				'"dependencies": [],'
+			);
+			logger.debug(
+				`JSON after fixing "dependencies": ${jsonToParse.substring(0, 500)}...`
+			);
+		}
+	}
+	// --- End pre-emptive cleanup ---
+
+	let parsedObject;
+	let primaryParseAttemptFailed = false;
+
+	// --- Attempt 1: Simple Parse (with optional Markdown cleanup) ---
+	logger.debug('Attempting simple parse...');
+	try {
+		// Check for markdown code block
+		const codeBlockMatch = jsonToParse.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+		let contentToParseDirectly = jsonToParse;
+		if (codeBlockMatch && codeBlockMatch[1]) {
+			contentToParseDirectly = codeBlockMatch[1].trim();
+			logger.debug('Simple parse: Extracted content from markdown code block.');
 		} else {
+			logger.debug(
+				'Simple parse: No markdown code block found, using trimmed original.'
+			);
+		}
+
+		parsedObject = JSON.parse(contentToParseDirectly);
+		logger.debug('Simple parse successful!');
+
+		// Quick check if it looks like our target object
+		if (
+			!parsedObject ||
+			typeof parsedObject !== 'object' ||
+			!Array.isArray(parsedObject.subtasks)
+		) {
 			logger.warn(
-				'Response does not appear to contain a JSON object structure. Parsing raw response.'
+				'Simple parse succeeded, but result is not the expected {"subtasks": []} structure. Will proceed to advanced extraction.'
+			);
+			primaryParseAttemptFailed = true;
+			parsedObject = null; // Reset parsedObject so we enter the advanced logic
+		}
+		// If it IS the correct structure, we'll skip advanced extraction.
+	} catch (e) {
+		logger.warn(
+			`Simple parse failed: ${e.message}. Proceeding to advanced extraction logic.`
+		);
+		primaryParseAttemptFailed = true;
+		// jsonToParse is already originalTrimmedResponse if simple parse failed before modifying it for markdown
+	}
+
+	// --- Attempt 2: Advanced Extraction (if simple parse failed or produced wrong structure) ---
+	if (primaryParseAttemptFailed || !parsedObject) {
+		// Ensure we try advanced if simple parse gave wrong structure
+		logger.debug('Attempting advanced extraction logic...');
+		// Reset jsonToParse to the original full trimmed response for advanced logic
+		jsonToParse = originalTrimmedResponse;
+
+		// (Insert the more complex extraction logic here - the one we worked on with:
+		//  - targetPattern = '{"subtasks":';
+		//  - careful brace counting for that targetPattern
+		//  - fallbacks to last '{' and '}' if targetPattern logic fails)
+		//  This was the logic from my previous message. Let's assume it's here.
+		//  This block should ultimately set `jsonToParse` to the best candidate string.
+
+		// Example snippet of that advanced logic's start:
+		const targetPattern = '{"subtasks":';
+		const patternStartIndex = jsonToParse.indexOf(targetPattern);
+
+		if (patternStartIndex !== -1) {
+			let openBraces = 0;
+			let firstBraceFound = false;
+			let extractedJsonBlock = '';
+			// ... (loop for brace counting as before) ...
+			// ... (if successful, jsonToParse = extractedJsonBlock) ...
+			// ... (if that fails, fallbacks as before) ...
+		} else {
+			// ... (fallback to last '{' and '}' if targetPattern not found) ...
+		}
+		// End of advanced logic excerpt
+
+		logger.debug(
+			`Advanced extraction: JSON string that will be parsed: ${jsonToParse.substring(0, 500)}...`
+		);
+		try {
+			parsedObject = JSON.parse(jsonToParse);
+			logger.debug('Advanced extraction parse successful!');
+		} catch (parseError) {
+			logger.error(
+				`Advanced extraction: Failed to parse JSON object: ${parseError.message}`
+			);
+			logger.error(
+				`Advanced extraction: Problematic JSON string for parse (first 500 chars): ${jsonToParse.substring(0, 500)}`
+			);
+			throw new Error( // Re-throw a more specific error if advanced also fails
+				`Failed to parse JSON response object after both simple and advanced attempts: ${parseError.message}`
 			);
 		}
 	}
 
-	// 3. Attempt to parse the object
+	// --- Validation (applies to successfully parsedObject from either attempt) ---
-	let parsedObject;
-	try {
-		parsedObject = JSON.parse(cleanedResponse);
-	} catch (parseError) {
-		logger.error(`Failed to parse JSON object: ${parseError.message}`);
-		logger.error(
-			`Problematic JSON string (first 500 chars): ${cleanedResponse.substring(0, 500)}`
-		);
-		logger.error(
-			`Original Raw Response (first 500 chars): ${originalResponseForDebug.substring(0, 500)}`
-		);
-		throw new Error(
-			`Failed to parse JSON response object: ${parseError.message}`
-		);
-	}
-
-	// 4. Validate the object structure and extract the subtasks array
 	if (
 		!parsedObject ||
 		typeof parsedObject !== 'object' ||
 		!Array.isArray(parsedObject.subtasks)
 	) {
 		logger.error(
-			`Parsed content is not an object or missing 'subtasks' array. Content: ${JSON.stringify(parsedObject).substring(0, 200)}`
+			`Final parsed content is not an object or missing 'subtasks' array. Content: ${JSON.stringify(parsedObject).substring(0, 200)}`
 		);
 		throw new Error(
-			'Parsed AI response is not a valid object containing a "subtasks" array.'
+			'Parsed AI response is not a valid object containing a "subtasks" array after all attempts.'
 		);
 	}
-	const parsedSubtasks = parsedObject.subtasks; // Extract the array
+	const parsedSubtasks = parsedObject.subtasks;
 
-	logger.info(
-		`Successfully parsed ${parsedSubtasks.length} potential subtasks from the object.`
-	);
 	if (expectedCount && parsedSubtasks.length !== expectedCount) {
 		logger.warn(
 			`Expected ${expectedCount} subtasks, but parsed ${parsedSubtasks.length}.`
 		);
 	}
 
-	// 5. Validate and Normalize each subtask using Zod schema
 	let currentId = startId;
 	const validatedSubtasks = [];
 	const validationErrors = [];
@@ -260,22 +342,21 @@ function parseSubtasksFromText(
 	for (const rawSubtask of parsedSubtasks) {
 		const correctedSubtask = {
 			...rawSubtask,
-			id: currentId, // Enforce sequential ID
+			id: currentId,
 			dependencies: Array.isArray(rawSubtask.dependencies)
 				? rawSubtask.dependencies
 						.map((dep) => (typeof dep === 'string' ? parseInt(dep, 10) : dep))
 						.filter(
 							(depId) => !isNaN(depId) && depId >= startId && depId < currentId
-						) // Ensure deps are numbers, valid range
+						)
 				: [],
-			status: 'pending' // Enforce pending status
+			status: 'pending'
-			// parentTaskId can be added if needed: parentTaskId: parentTaskId
 		};
 
 		const result = subtaskSchema.safeParse(correctedSubtask);
 
 		if (result.success) {
-			validatedSubtasks.push(result.data); // Add the validated data
+			validatedSubtasks.push(result.data);
 		} else {
 			logger.warn(
 				`Subtask validation failed for raw data: ${JSON.stringify(rawSubtask).substring(0, 100)}...`
@@ -285,18 +366,14 @@ function parseSubtasksFromText(
 				logger.warn(errorMessage);
 				validationErrors.push(`Subtask ${currentId}: ${errorMessage}`);
 			});
-			// Optionally, decide whether to include partially valid tasks or skip them
-			// For now, we'll skip invalid ones
 		}
-		currentId++; // Increment ID for the next *potential* subtask
+		currentId++;
 	}
 
 	if (validationErrors.length > 0) {
 		logger.error(
 			`Found ${validationErrors.length} validation errors in the generated subtasks.`
 		);
-		// Optionally throw an error here if strict validation is required
-		// throw new Error(`Subtask validation failed:\n${validationErrors.join('\n')}`);
 		logger.warn('Proceeding with only the successfully validated subtasks.');
 	}
 
@@ -305,8 +382,6 @@ function parseSubtasksFromText(
 			'AI response contained potential subtasks, but none passed validation.'
 		);
 	}
-
-	// Ensure we don't return more than expected, preferring validated ones
 	return validatedSubtasks.slice(0, expectedCount || validatedSubtasks.length);
 }
 
@@ -336,9 +411,13 @@ async function expandTask(
 	context = {},
 	force = false
 ) {
-	const { session, mcpLog } = context;
+	const { session, mcpLog, projectRoot: contextProjectRoot } = context;
 	const outputFormat = mcpLog ? 'json' : 'text';
 
+	// Determine projectRoot: Use from context if available, otherwise derive from tasksPath
+	const projectRoot =
+		contextProjectRoot || path.dirname(path.dirname(tasksPath));
+
 	// Use mcpLog if available, otherwise use the default console log wrapper
 	const logger = mcpLog || {
 		info: (msg) => !isSilentMode() && log('info', msg),
@@ -363,7 +442,9 @@ async function expandTask(
 		);
 		if (taskIndex === -1) throw new Error(`Task ${taskId} not found`);
 		const task = data.tasks[taskIndex];
-		logger.info(`Expanding task ${taskId}: ${task.title}`);
+		logger.info(
+			`Expanding task ${taskId}: ${task.title}${useResearch ? ' with research' : ''}`
+		);
 		// --- End Task Loading/Filtering ---
 
 		// --- Handle Force Flag: Clear existing subtasks if force=true ---
@@ -381,7 +462,6 @@ async function expandTask(
 		let complexityReasoningContext = '';
 		let systemPrompt; // Declare systemPrompt here
 
-		const projectRoot = path.dirname(path.dirname(tasksPath));
 		const complexityReportPath = path.join(
 			projectRoot,
 			'scripts/task-complexity-report.json'
@@ -488,28 +568,27 @@ async function expandTask(
 		let loadingIndicator = null;
 		if (outputFormat === 'text') {
 			loadingIndicator = startLoadingIndicator(
-				`Generating ${finalSubtaskCount} subtasks...`
+				`Generating ${finalSubtaskCount} subtasks...\n`
 			);
 		}
 
 		let responseText = '';
+		let aiServiceResponse = null;
 
 		try {
 			const role = useResearch ? 'research' : 'main';
-			logger.info(`Using AI service with role: ${role}`);
 
-			// Call generateTextService with the determined prompts
+			// Call generateTextService with the determined prompts and telemetry params
-			responseText = await generateTextService({
+			aiServiceResponse = await generateTextService({
 				prompt: promptContent,
-				systemPrompt: systemPrompt, // Use the determined system prompt
+				systemPrompt: systemPrompt,
 				role,
 				session,
-				projectRoot
+				projectRoot,
+				commandName: 'expand-task',
+				outputType: outputFormat
 			});
-			logger.info(
+			responseText = aiServiceResponse.mainResult;
-				'Successfully received text response from AI service',
-				'success'
-			);
 
 			// Parse Subtasks
 			generatedSubtasks = parseSubtasksFromText(
@@ -550,14 +629,23 @@ async function expandTask(
 		// --- End Change: Append instead of replace ---
 
 		data.tasks[taskIndex] = task; // Assign the modified task back
-		logger.info(`Writing updated tasks to ${tasksPath}`);
 		writeJSON(tasksPath, data);
-		logger.info(`Generating individual task files...`);
 		await generateTaskFiles(tasksPath, path.dirname(tasksPath));
-		logger.info(`Task files generated.`);
-		// --- End Task Update & File Writing ---
 
-		return task; // Return the updated task object
+		// Display AI Usage Summary for CLI
+		if (
+			outputFormat === 'text' &&
+			aiServiceResponse &&
+			aiServiceResponse.telemetryData
+		) {
+			displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli');
+		}
+
+		// Return the updated task object AND telemetry data
+		return {
+			task,
+			telemetryData: aiServiceResponse?.telemetryData
+		};
 	} catch (error) {
 		// Catches errors from file reading, parsing, AI call etc.
 		logger.error(`Error expanding task ${taskId}: ${error.message}`, 'error');

scripts/modules/task-manager/generate-task-files.js

@@ -19,8 +19,6 @@ function generateTaskFiles(tasksPath, outputDir, options = {}) {
 		// Determine if we're in MCP mode by checking for mcpLog
 		const isMcpMode = !!options?.mcpLog;
 
-		log('info', `Preparing to regenerate task files in ${tasksPath}`);
-
 		const data = readJSON(tasksPath);
 		if (!data || !data.tasks) {
 			throw new Error(`No valid tasks found in ${tasksPath}`);
@@ -31,12 +29,59 @@ function generateTaskFiles(tasksPath, outputDir, options = {}) {
 			fs.mkdirSync(outputDir, { recursive: true });
 		}
 
-		log('info', `Found ${data.tasks.length} tasks to regenerate`);
+		log('info', `Preparing to regenerate ${data.tasks.length} task files`);
 
 		// Validate and fix dependencies before generating files
 		log('info', `Validating and fixing dependencies`);
 		validateAndFixDependencies(data, tasksPath);
 
+		// Get valid task IDs from tasks.json
+		const validTaskIds = data.tasks.map((task) => task.id);
+
+		// Cleanup orphaned task files
+		log('info', 'Checking for orphaned task files to clean up...');
+		try {
+			// Get all task files in the output directory
+			const files = fs.readdirSync(outputDir);
+			const taskFilePattern = /^task_(\d+)\.txt$/;
+
+			// Filter for task files and check if they match a valid task ID
+			const orphanedFiles = files.filter((file) => {
+				const match = file.match(taskFilePattern);
+				if (match) {
+					const fileTaskId = parseInt(match[1], 10);
+					return !validTaskIds.includes(fileTaskId);
+				}
+				return false;
+			});
+
+			// Delete orphaned files
+			if (orphanedFiles.length > 0) {
+				log(
+					'info',
+					`Found ${orphanedFiles.length} orphaned task files to remove`
+				);
+
+				orphanedFiles.forEach((file) => {
+					const filePath = path.join(outputDir, file);
+					try {
+						fs.unlinkSync(filePath);
+						log('info', `Removed orphaned task file: ${file}`);
+					} catch (err) {
+						log(
+							'warn',
+							`Failed to remove orphaned task file ${file}: ${err.message}`
+						);
+					}
+				});
+			} else {
+				log('info', 'No orphaned task files found');
+			}
+		} catch (err) {
+			log('warn', `Error cleaning up orphaned task files: ${err.message}`);
+			// Continue with file generation even if cleanup fails
+		}
+
 		// Generate task files
 		log('info', 'Generating individual task files...');
 		data.tasks.forEach((task) => {

scripts/modules/task-manager/models.js

@@ -6,6 +6,7 @@
 import path from 'path';
 import fs from 'fs';
 import https from 'https';
+import http from 'http';
 import {
 	getMainModelId,
 	getResearchModelId,
@@ -19,7 +20,8 @@ import {
 	getConfig,
 	writeConfig,
 	isConfigFilePresent,
-	getAllProviders
+	getAllProviders,
+	getBaseUrlForRole
 } from '../config-manager.js';
 
 /**
@@ -68,6 +70,68 @@ function fetchOpenRouterModels() {
 	});
 }
 
+/**
+ * Fetches the list of models from Ollama instance.
+ * @param {string} baseURL - The base URL for the Ollama API (e.g., "http://localhost:11434/api")
+ * @returns {Promise<Array|null>} A promise that resolves with the list of model objects or null if fetch fails.
+ */
+function fetchOllamaModels(baseURL = 'http://localhost:11434/api') {
+	return new Promise((resolve) => {
+		try {
+			// Parse the base URL to extract hostname, port, and base path
+			const url = new URL(baseURL);
+			const isHttps = url.protocol === 'https:';
+			const port = url.port || (isHttps ? 443 : 80);
+			const basePath = url.pathname.endsWith('/')
+				? url.pathname.slice(0, -1)
+				: url.pathname;
+
+			const options = {
+				hostname: url.hostname,
+				port: parseInt(port, 10),
+				path: `${basePath}/tags`,
+				method: 'GET',
+				headers: {
+					Accept: 'application/json'
+				}
+			};
+
+			const requestLib = isHttps ? https : http;
+			const req = requestLib.request(options, (res) => {
+				let data = '';
+				res.on('data', (chunk) => {
+					data += chunk;
+				});
+				res.on('end', () => {
+					if (res.statusCode === 200) {
+						try {
+							const parsedData = JSON.parse(data);
+							resolve(parsedData.models || []); // Return the array of models
+						} catch (e) {
+							console.error('Error parsing Ollama response:', e);
+							resolve(null); // Indicate failure
+						}
+					} else {
+						console.error(
+							`Ollama API request failed with status code: ${res.statusCode}`
+						);
+						resolve(null); // Indicate failure
+					}
+				});
+			});
+
+			req.on('error', (e) => {
+				console.error('Error fetching Ollama models:', e);
+				resolve(null); // Indicate failure
+			});
+			req.end();
+		} catch (e) {
+			console.error('Error parsing Ollama base URL:', e);
+			resolve(null); // Indicate failure
+		}
+	});
+}
+
 /**
  * Get the current model configuration
  * @param {Object} [options] - Options for the operation
@@ -416,10 +480,29 @@ async function setModel(role, modelId, options = {}) {
 						);
 					}
 				} else if (providerHint === 'ollama') {
-					// Hinted as Ollama - set provider directly WITHOUT checking OpenRouter
+					// Check Ollama ONLY because hint was ollama
-					determinedProvider = 'ollama';
+					report('info', `Checking Ollama for ${modelId} (as hinted)...`);
-					warningMessage = `Warning: Custom Ollama model '${modelId}' set. Ensure your Ollama server is running and has pulled this model. Taskmaster cannot guarantee compatibility.`;
+
-					report('warn', warningMessage);
+					// Get the Ollama base URL from config
+					const ollamaBaseURL = getBaseUrlForRole(role, projectRoot);
+					const ollamaModels = await fetchOllamaModels(ollamaBaseURL);
+
+					if (ollamaModels === null) {
+						// Connection failed - server probably not running
+						throw new Error(
+							`Unable to connect to Ollama server at ${ollamaBaseURL}. Please ensure Ollama is running and try again.`
+						);
+					} else if (ollamaModels.some((m) => m.model === modelId)) {
+						determinedProvider = 'ollama';
+						warningMessage = `Warning: Custom Ollama model '${modelId}' set. Ensure your Ollama server is running and has pulled this model. Taskmaster cannot guarantee compatibility.`;
+						report('warn', warningMessage);
+					} else {
+						// Server is running but model not found
+						const tagsUrl = `${ollamaBaseURL}/tags`;
+						throw new Error(
+							`Model ID "${modelId}" not found in the Ollama instance. Please verify the model is pulled and available. You can check available models with: curl ${tagsUrl}`
+						);
+					}
 				} else {
 					// Invalid provider hint - should not happen
 					throw new Error(`Invalid provider hint received: ${providerHint}`);

scripts/modules/task-manager/move-task.js

@@ -0,0 +1,571 @@
+import path from 'path';
+import { log, readJSON, writeJSON } from '../utils.js';
+import { isTaskDependentOn } from '../task-manager.js';
+import generateTaskFiles from './generate-task-files.js';
+
+/**
+ * Move a task or subtask to a new position
+ * @param {string} tasksPath - Path to tasks.json file
+ * @param {string} sourceId - ID of the task/subtask to move (e.g., '5' or '5.2')
+ * @param {string} destinationId - ID of the destination (e.g., '7' or '7.3')
+ * @param {boolean} generateFiles - Whether to regenerate task files after moving
+ * @returns {Object} Result object with moved task details
+ */
+async function moveTask(
+	tasksPath,
+	sourceId,
+	destinationId,
+	generateFiles = true
+) {
+	try {
+		log('info', `Moving task/subtask ${sourceId} to ${destinationId}...`);
+
+		// Read the existing tasks
+		const data = readJSON(tasksPath);
+		if (!data || !data.tasks) {
+			throw new Error(`Invalid or missing tasks file at ${tasksPath}`);
+		}
+
+		// Parse source ID to determine if it's a task or subtask
+		const isSourceSubtask = sourceId.includes('.');
+		let sourceTask,
+			sourceParentTask,
+			sourceSubtask,
+			sourceTaskIndex,
+			sourceSubtaskIndex;
+
+		// Parse destination ID to determine the target
+		const isDestinationSubtask = destinationId.includes('.');
+		let destTask, destParentTask, destSubtask, destTaskIndex, destSubtaskIndex;
+
+		// Validate source exists
+		if (isSourceSubtask) {
+			// Source is a subtask
+			const [parentIdStr, subtaskIdStr] = sourceId.split('.');
+			const parentIdNum = parseInt(parentIdStr, 10);
+			const subtaskIdNum = parseInt(subtaskIdStr, 10);
+
+			sourceParentTask = data.tasks.find((t) => t.id === parentIdNum);
+			if (!sourceParentTask) {
+				throw new Error(`Source parent task with ID ${parentIdNum} not found`);
+			}
+
+			if (
+				!sourceParentTask.subtasks ||
+				sourceParentTask.subtasks.length === 0
+			) {
+				throw new Error(`Source parent task ${parentIdNum} has no subtasks`);
+			}
+
+			sourceSubtaskIndex = sourceParentTask.subtasks.findIndex(
+				(st) => st.id === subtaskIdNum
+			);
+			if (sourceSubtaskIndex === -1) {
+				throw new Error(`Source subtask ${sourceId} not found`);
+			}
+
+			sourceSubtask = { ...sourceParentTask.subtasks[sourceSubtaskIndex] };
+		} else {
+			// Source is a task
+			const sourceIdNum = parseInt(sourceId, 10);
+			sourceTaskIndex = data.tasks.findIndex((t) => t.id === sourceIdNum);
+			if (sourceTaskIndex === -1) {
+				throw new Error(`Source task with ID ${sourceIdNum} not found`);
+			}
+
+			sourceTask = { ...data.tasks[sourceTaskIndex] };
+		}
+
+		// Validate destination exists
+		if (isDestinationSubtask) {
+			// Destination is a subtask (target will be the parent of this subtask)
+			const [parentIdStr, subtaskIdStr] = destinationId.split('.');
+			const parentIdNum = parseInt(parentIdStr, 10);
+			const subtaskIdNum = parseInt(subtaskIdStr, 10);
+
+			destParentTask = data.tasks.find((t) => t.id === parentIdNum);
+			if (!destParentTask) {
+				throw new Error(
+					`Destination parent task with ID ${parentIdNum} not found`
+				);
+			}
+
+			if (!destParentTask.subtasks || destParentTask.subtasks.length === 0) {
+				throw new Error(
+					`Destination parent task ${parentIdNum} has no subtasks`
+				);
+			}
+
+			destSubtaskIndex = destParentTask.subtasks.findIndex(
+				(st) => st.id === subtaskIdNum
+			);
+			if (destSubtaskIndex === -1) {
+				throw new Error(`Destination subtask ${destinationId} not found`);
+			}
+
+			destSubtask = destParentTask.subtasks[destSubtaskIndex];
+		} else {
+			// Destination is a task
+			const destIdNum = parseInt(destinationId, 10);
+			destTaskIndex = data.tasks.findIndex((t) => t.id === destIdNum);
+
+			if (destTaskIndex === -1) {
+				// Create placeholder for destination if it doesn't exist
+				log('info', `Creating placeholder for destination task ${destIdNum}`);
+				const newTask = {
+					id: destIdNum,
+					title: `Task ${destIdNum}`,
+					description: '',
+					status: 'pending',
+					priority: 'medium',
+					details: '',
+					testStrategy: ''
+				};
+
+				// Find correct position to insert the new task
+				let insertIndex = 0;
+				while (
+					insertIndex < data.tasks.length &&
+					data.tasks[insertIndex].id < destIdNum
+				) {
+					insertIndex++;
+				}
+
+				// Insert the new task at the appropriate position
+				data.tasks.splice(insertIndex, 0, newTask);
+				destTaskIndex = insertIndex;
+				destTask = data.tasks[destTaskIndex];
+			} else {
+				destTask = data.tasks[destTaskIndex];
+
+				// Check if destination task is already a "real" task with content
+				// Only allow moving to destination IDs that don't have meaningful content
+				if (
+					destTask.title !== `Task ${destTask.id}` ||
+					destTask.description !== '' ||
+					destTask.details !== ''
+				) {
+					throw new Error(
+						`Cannot move to task ID ${destIdNum} as it already contains content. Choose a different destination ID.`
+					);
+				}
+			}
+		}
+
+		// Validate that we aren't trying to move a task to itself
+		if (sourceId === destinationId) {
+			throw new Error('Cannot move a task/subtask to itself');
+		}
+
+		// Prevent moving a parent to its own subtask
+		if (!isSourceSubtask && isDestinationSubtask) {
+			const destParentId = parseInt(destinationId.split('.')[0], 10);
+			if (parseInt(sourceId, 10) === destParentId) {
+				throw new Error('Cannot move a parent task to one of its own subtasks');
+			}
+		}
+
+		// Check for circular dependency when moving tasks
+		if (!isSourceSubtask && !isDestinationSubtask) {
+			const sourceIdNum = parseInt(sourceId, 10);
+			const destIdNum = parseInt(destinationId, 10);
+
+			// Check if destination is dependent on source
+			if (isTaskDependentOn(data.tasks, destTask, sourceIdNum)) {
+				throw new Error(
+					`Cannot move task ${sourceId} to task ${destinationId} as it would create a circular dependency`
+				);
+			}
+		}
+
+		let movedTask;
+
+		// Handle different move scenarios
+		if (!isSourceSubtask && !isDestinationSubtask) {
+			// Check if destination is a placeholder we just created
+			if (
+				destTask.title === `Task ${destTask.id}` &&
+				destTask.description === '' &&
+				destTask.details === ''
+			) {
+				// Case 0: Move task to a new position/ID (destination is a placeholder)
+				movedTask = moveTaskToNewId(
+					data,
+					sourceTask,
+					sourceTaskIndex,
+					destTask,
+					destTaskIndex
+				);
+			} else {
+				// Case 1: Move standalone task to become a subtask of another task
+				movedTask = moveTaskToTask(data, sourceTask, sourceTaskIndex, destTask);
+			}
+		} else if (!isSourceSubtask && isDestinationSubtask) {
+			// Case 2: Move standalone task to become a subtask at a specific position
+			movedTask = moveTaskToSubtaskPosition(
+				data,
+				sourceTask,
+				sourceTaskIndex,
+				destParentTask,
+				destSubtaskIndex
+			);
+		} else if (isSourceSubtask && !isDestinationSubtask) {
+			// Case 3: Move subtask to become a standalone task
+			movedTask = moveSubtaskToTask(
+				data,
+				sourceSubtask,
+				sourceParentTask,
+				sourceSubtaskIndex,
+				destTask
+			);
+		} else if (isSourceSubtask && isDestinationSubtask) {
+			// Case 4: Move subtask to another parent or position
+			// First check if it's the same parent
+			const sourceParentId = parseInt(sourceId.split('.')[0], 10);
+			const destParentId = parseInt(destinationId.split('.')[0], 10);
+
+			if (sourceParentId === destParentId) {
+				// Case 4a: Move subtask within the same parent (reordering)
+				movedTask = reorderSubtask(
+					sourceParentTask,
+					sourceSubtaskIndex,
+					destSubtaskIndex
+				);
+			} else {
+				// Case 4b: Move subtask to a different parent
+				movedTask = moveSubtaskToAnotherParent(
+					sourceSubtask,
+					sourceParentTask,
+					sourceSubtaskIndex,
+					destParentTask,
+					destSubtaskIndex
+				);
+			}
+		}
+
+		// Write the updated tasks back to the file
+		writeJSON(tasksPath, data);
+
+		// Generate task files if requested
+		if (generateFiles) {
+			log('info', 'Regenerating task files...');
+			await generateTaskFiles(tasksPath, path.dirname(tasksPath));
+		}
+
+		return movedTask;
+	} catch (error) {
+		log('error', `Error moving task/subtask: ${error.message}`);
+		throw error;
+	}
+}
+
+/**
+ * Move a standalone task to become a subtask of another task
+ * @param {Object} data - Tasks data object
+ * @param {Object} sourceTask - Source task to move
+ * @param {number} sourceTaskIndex - Index of source task in data.tasks
+ * @param {Object} destTask - Destination task
+ * @returns {Object} Moved task object
+ */
+function moveTaskToTask(data, sourceTask, sourceTaskIndex, destTask) {
+	// Initialize subtasks array if it doesn't exist
+	if (!destTask.subtasks) {
+		destTask.subtasks = [];
+	}
+
+	// Find the highest subtask ID to determine the next ID
+	const highestSubtaskId =
+		destTask.subtasks.length > 0
+			? Math.max(...destTask.subtasks.map((st) => st.id))
+			: 0;
+	const newSubtaskId = highestSubtaskId + 1;
+
+	// Create the new subtask from the source task
+	const newSubtask = {
+		...sourceTask,
+		id: newSubtaskId,
+		parentTaskId: destTask.id
+	};
+
+	// Add to destination's subtasks
+	destTask.subtasks.push(newSubtask);
+
+	// Remove the original task from the tasks array
+	data.tasks.splice(sourceTaskIndex, 1);
+
+	log(
+		'info',
+		`Moved task ${sourceTask.id} to become subtask ${destTask.id}.${newSubtaskId}`
+	);
+
+	return newSubtask;
+}
+
+/**
+ * Move a standalone task to become a subtask at a specific position
+ * @param {Object} data - Tasks data object
+ * @param {Object} sourceTask - Source task to move
+ * @param {number} sourceTaskIndex - Index of source task in data.tasks
+ * @param {Object} destParentTask - Destination parent task
+ * @param {number} destSubtaskIndex - Index of the subtask before which to insert
+ * @returns {Object} Moved task object
+ */
+function moveTaskToSubtaskPosition(
+	data,
+	sourceTask,
+	sourceTaskIndex,
+	destParentTask,
+	destSubtaskIndex
+) {
+	// Initialize subtasks array if it doesn't exist
+	if (!destParentTask.subtasks) {
+		destParentTask.subtasks = [];
+	}
+
+	// Find the highest subtask ID to determine the next ID
+	const highestSubtaskId =
+		destParentTask.subtasks.length > 0
+			? Math.max(...destParentTask.subtasks.map((st) => st.id))
+			: 0;
+	const newSubtaskId = highestSubtaskId + 1;
+
+	// Create the new subtask from the source task
+	const newSubtask = {
+		...sourceTask,
+		id: newSubtaskId,
+		parentTaskId: destParentTask.id
+	};
+
+	// Insert at specific position
+	destParentTask.subtasks.splice(destSubtaskIndex + 1, 0, newSubtask);
+
+	// Remove the original task from the tasks array
+	data.tasks.splice(sourceTaskIndex, 1);
+
+	log(
+		'info',
+		`Moved task ${sourceTask.id} to become subtask ${destParentTask.id}.${newSubtaskId}`
+	);
+
+	return newSubtask;
+}
+
+/**
+ * Move a subtask to become a standalone task
+ * @param {Object} data - Tasks data object
+ * @param {Object} sourceSubtask - Source subtask to move
+ * @param {Object} sourceParentTask - Parent task of the source subtask
+ * @param {number} sourceSubtaskIndex - Index of source subtask in parent's subtasks
+ * @param {Object} destTask - Destination task (for position reference)
+ * @returns {Object} Moved task object
+ */
+function moveSubtaskToTask(
+	data,
+	sourceSubtask,
+	sourceParentTask,
+	sourceSubtaskIndex,
+	destTask
+) {
+	// Find the highest task ID to determine the next ID
+	const highestId = Math.max(...data.tasks.map((t) => t.id));
+	const newTaskId = highestId + 1;
+
+	// Create the new task from the subtask
+	const newTask = {
+		...sourceSubtask,
+		id: newTaskId,
+		priority: sourceParentTask.priority || 'medium' // Inherit priority from parent
+	};
+	delete newTask.parentTaskId;
+
+	// Add the parent task as a dependency if not already present
+	if (!newTask.dependencies) {
+		newTask.dependencies = [];
+	}
+	if (!newTask.dependencies.includes(sourceParentTask.id)) {
+		newTask.dependencies.push(sourceParentTask.id);
+	}
+
+	// Find the destination index to insert the new task
+	const destTaskIndex = data.tasks.findIndex((t) => t.id === destTask.id);
+
+	// Insert the new task after the destination task
+	data.tasks.splice(destTaskIndex + 1, 0, newTask);
+
+	// Remove the subtask from the parent
+	sourceParentTask.subtasks.splice(sourceSubtaskIndex, 1);
+
+	// If parent has no more subtasks, remove the subtasks array
+	if (sourceParentTask.subtasks.length === 0) {
+		delete sourceParentTask.subtasks;
+	}
+
+	log(
+		'info',
+		`Moved subtask ${sourceParentTask.id}.${sourceSubtask.id} to become task ${newTaskId}`
+	);
+
+	return newTask;
+}
+
+/**
+ * Reorder a subtask within the same parent
+ * @param {Object} parentTask - Parent task containing the subtask
+ * @param {number} sourceIndex - Current index of the subtask
+ * @param {number} destIndex - Destination index for the subtask
+ * @returns {Object} Moved subtask object
+ */
+function reorderSubtask(parentTask, sourceIndex, destIndex) {
+	// Get the subtask to move
+	const subtask = parentTask.subtasks[sourceIndex];
+
+	// Remove the subtask from its current position
+	parentTask.subtasks.splice(sourceIndex, 1);
+
+	// Insert the subtask at the new position
+	// If destIndex was after sourceIndex, it's now one less because we removed an item
+	const adjustedDestIndex = sourceIndex < destIndex ? destIndex - 1 : destIndex;
+	parentTask.subtasks.splice(adjustedDestIndex, 0, subtask);
+
+	log(
+		'info',
+		`Reordered subtask ${parentTask.id}.${subtask.id} within parent task ${parentTask.id}`
+	);
+
+	return subtask;
+}
+
+/**
+ * Move a subtask to a different parent
+ * @param {Object} sourceSubtask - Source subtask to move
+ * @param {Object} sourceParentTask - Parent task of the source subtask
+ * @param {number} sourceSubtaskIndex - Index of source subtask in parent's subtasks
+ * @param {Object} destParentTask - Destination parent task
+ * @param {number} destSubtaskIndex - Index of the subtask before which to insert
+ * @returns {Object} Moved subtask object
+ */
+function moveSubtaskToAnotherParent(
+	sourceSubtask,
+	sourceParentTask,
+	sourceSubtaskIndex,
+	destParentTask,
+	destSubtaskIndex
+) {
+	// Find the highest subtask ID in the destination parent
+	const highestSubtaskId =
+		destParentTask.subtasks.length > 0
+			? Math.max(...destParentTask.subtasks.map((st) => st.id))
+			: 0;
+	const newSubtaskId = highestSubtaskId + 1;
+
+	// Create the new subtask with updated parent reference
+	const newSubtask = {
+		...sourceSubtask,
+		id: newSubtaskId,
+		parentTaskId: destParentTask.id
+	};
+
+	// If the subtask depends on its original parent, keep that dependency
+	if (!newSubtask.dependencies) {
+		newSubtask.dependencies = [];
+	}
+	if (!newSubtask.dependencies.includes(sourceParentTask.id)) {
+		newSubtask.dependencies.push(sourceParentTask.id);
+	}
+
+	// Insert at the destination position
+	destParentTask.subtasks.splice(destSubtaskIndex + 1, 0, newSubtask);
+
+	// Remove the subtask from the original parent
+	sourceParentTask.subtasks.splice(sourceSubtaskIndex, 1);
+
+	// If original parent has no more subtasks, remove the subtasks array
+	if (sourceParentTask.subtasks.length === 0) {
+		delete sourceParentTask.subtasks;
+	}
+
+	log(
+		'info',
+		`Moved subtask ${sourceParentTask.id}.${sourceSubtask.id} to become subtask ${destParentTask.id}.${newSubtaskId}`
+	);
+
+	return newSubtask;
+}
+
+/**
+ * Move a standalone task to a new ID position
+ * @param {Object} data - Tasks data object
+ * @param {Object} sourceTask - Source task to move
+ * @param {number} sourceTaskIndex - Index of source task in data.tasks
+ * @param {Object} destTask - Destination placeholder task
+ * @param {number} destTaskIndex - Index of destination task in data.tasks
+ * @returns {Object} Moved task object
+ */
+function moveTaskToNewId(
+	data,
+	sourceTask,
+	sourceTaskIndex,
+	destTask,
+	destTaskIndex
+) {
+	// Create a copy of the source task with the new ID
+	const movedTask = {
+		...sourceTask,
+		id: destTask.id
+	};
+
+	// Get numeric IDs for comparison
+	const sourceIdNum = parseInt(sourceTask.id, 10);
+	const destIdNum = parseInt(destTask.id, 10);
+
+	// Handle subtasks if present
+	if (sourceTask.subtasks && sourceTask.subtasks.length > 0) {
+		// Update subtasks to reference the new parent ID if needed
+		movedTask.subtasks = sourceTask.subtasks.map((subtask) => ({
+			...subtask,
+			parentTaskId: destIdNum
+		}));
+	}
+
+	// Update any dependencies in other tasks that referenced the old ID
+	data.tasks.forEach((task) => {
+		if (task.dependencies && task.dependencies.includes(sourceIdNum)) {
+			// Replace the old ID with the new ID
+			const depIndex = task.dependencies.indexOf(sourceIdNum);
+			task.dependencies[depIndex] = destIdNum;
+		}
+
+		// Also check for subtask dependencies that might reference this task
+		if (task.subtasks && task.subtasks.length > 0) {
+			task.subtasks.forEach((subtask) => {
+				if (
+					subtask.dependencies &&
+					subtask.dependencies.includes(sourceIdNum)
+				) {
+					const depIndex = subtask.dependencies.indexOf(sourceIdNum);
+					subtask.dependencies[depIndex] = destIdNum;
+				}
+			});
+		}
+	});
+
+	// Remove the original task from its position
+	data.tasks.splice(sourceTaskIndex, 1);
+
+	// If we're moving to a position after the original, adjust the destination index
+	// since removing the original shifts everything down by 1
+	const adjustedDestIndex =
+		sourceTaskIndex < destTaskIndex ? destTaskIndex - 1 : destTaskIndex;
+
+	// Remove the placeholder destination task
+	data.tasks.splice(adjustedDestIndex, 1);
+
+	// Insert the moved task at the destination position
+	data.tasks.splice(adjustedDestIndex, 0, movedTask);
+
+	log('info', `Moved task ${sourceIdNum} to new ID ${destIdNum}`);
+
+	return movedTask;
+}
+
+export default moveTask;

scripts/modules/task-manager/parse-prd.js

@@ -17,6 +17,7 @@ import {
 import { generateObjectService } from '../ai-services-unified.js';
 import { getDebugFlag } from '../config-manager.js';
 import generateTaskFiles from './generate-task-files.js';
+import { displayAiUsageSummary } from '../ui.js';
 
 // Define the Zod schema for a SINGLE task object
 const prdSingleTaskSchema = z.object({
@@ -47,8 +48,9 @@ const prdResponseSchema = z.object({
  * @param {string} tasksPath - Path to the tasks.json file
  * @param {number} numTasks - Number of tasks to generate
  * @param {Object} options - Additional options
- * @param {boolean} [options.useForce=false] - Whether to overwrite existing tasks.json.
+ * @param {boolean} [options.force=false] - Whether to overwrite existing tasks.json.
- * @param {boolean} [options.useAppend=false] - Append to existing tasks file.
+ * @param {boolean} [options.append=false] - Append to existing tasks file.
+ * @param {boolean} [options.research=false] - Use research model for enhanced PRD analysis.
  * @param {Object} [options.reportProgress] - Function to report progress (optional, likely unused).
  * @param {Object} [options.mcpLog] - MCP logger object (optional).
  * @param {Object} [options.session] - Session object from MCP server (optional).
@@ -61,8 +63,9 @@ async function parsePRD(prdPath, tasksPath, numTasks, options = {}) {
 		mcpLog,
 		session,
 		projectRoot,
-		useForce = false,
+		force = false,
-		useAppend = false
+		append = false,
+		research = false
 	} = options;
 	const isMCP = !!mcpLog;
 	const outputFormat = isMCP ? 'json' : 'text';
@@ -90,16 +93,17 @@ async function parsePRD(prdPath, tasksPath, numTasks, options = {}) {
 	};
 
 	report(
-		`Parsing PRD file: ${prdPath}, Force: ${useForce}, Append: ${useAppend}`
+		`Parsing PRD file: ${prdPath}, Force: ${force}, Append: ${append}, Research: ${research}`
 	);
 
 	let existingTasks = [];
 	let nextId = 1;
+	let aiServiceResponse = null;
 
 	try {
 		// Handle file existence and overwrite/append logic
 		if (fs.existsSync(tasksPath)) {
-			if (useAppend) {
+			if (append) {
 				report(
 					`Append mode enabled. Reading existing tasks from ${tasksPath}`,
 					'info'
@@ -121,7 +125,7 @@ async function parsePRD(prdPath, tasksPath, numTasks, options = {}) {
 					);
 					existingTasks = []; // Reset if read fails
 				}
-			} else if (!useForce) {
+			} else if (!force) {
 				// Not appending and not forcing overwrite
 				const overwriteError = new Error(
 					`Output file ${tasksPath} already exists. Use --force to overwrite or --append.`
@@ -148,8 +152,22 @@ async function parsePRD(prdPath, tasksPath, numTasks, options = {}) {
 			throw new Error(`Input file ${prdPath} is empty or could not be read.`);
 		}
 
-		// Build system prompt for PRD parsing
+		// Research-specific enhancements to the system prompt
-		const systemPrompt = `You are an AI assistant specialized in analyzing Product Requirements Documents (PRDs) and generating a structured, logically ordered, dependency-aware and sequenced list of development tasks in JSON format.
+		const researchPromptAddition = research
+			? `\nBefore breaking down the PRD into tasks, you will:
+1. Research and analyze the latest technologies, libraries, frameworks, and best practices that would be appropriate for this project
+2. Identify any potential technical challenges, security concerns, or scalability issues not explicitly mentioned in the PRD without discarding any explicit requirements or going overboard with complexity -- always aim to provide the most direct path to implementation, avoiding over-engineering or roundabout approaches
+3. Consider current industry standards and evolving trends relevant to this project (this step aims to solve LLM hallucinations and out of date information due to training data cutoff dates)
+4. Evaluate alternative implementation approaches and recommend the most efficient path
+5. Include specific library versions, helpful APIs, and concrete implementation guidance based on your research
+6. Always aim to provide the most direct path to implementation, avoiding over-engineering or roundabout approaches
+
+Your task breakdown should incorporate this research, resulting in more detailed implementation guidance, more accurate dependency mapping, and more precise technology recommendations than would be possible from the PRD text alone, while maintaining all explicit requirements and best practices and all details and nuances of the PRD.`
+			: '';
+
+		// Base system prompt for PRD parsing
+		const systemPrompt = `You are an AI assistant specialized in analyzing Product Requirements Documents (PRDs) and generating a structured, logically ordered, dependency-aware and sequenced list of development tasks in JSON format.${researchPromptAddition}
+
 Analyze the provided PRD content and generate approximately ${numTasks} top-level development tasks. If the complexity or the level of detail of the PRD is high, generate more tasks relative to the complexity of the PRD
 Each task should represent a logical unit of work needed to implement the requirements and focus on the most direct and effective way to implement the requirements without unnecessary complexity or overengineering. Include pseudo-code, implementation details, and test strategy for each task. Find the most up to date information to implement each task.
 Assign sequential IDs starting from ${nextId}. Infer title, description, details, and test strategy for each task based *only* on the PRD content.
@@ -176,13 +194,13 @@ Guidelines:
 5. Include clear validation/testing approach for each task
 6. Set appropriate dependency IDs (a task can only depend on tasks with lower IDs, potentially including existing tasks with IDs less than ${nextId} if applicable)
 7. Assign priority (high/medium/low) based on criticality and dependency order
-8. Include detailed implementation guidance in the "details" field
+8. Include detailed implementation guidance in the "details" field${research ? ', with specific libraries and version recommendations based on your research' : ''}
 9. If the PRD contains specific requirements for libraries, database schemas, frameworks, tech stacks, or any other implementation details, STRICTLY ADHERE to these requirements in your task breakdown and do not discard them under any circumstance
 10. Focus on filling in any gaps left by the PRD or areas that aren't fully specified, while preserving all explicit requirements
-11. Always aim to provide the most direct path to implementation, avoiding over-engineering or roundabout approaches`;
+11. Always aim to provide the most direct path to implementation, avoiding over-engineering or roundabout approaches${research ? '\n12. For each task, include specific, actionable guidance based on current industry standards and best practices discovered through research' : ''}`;
 
 		// Build user prompt with PRD content
-		const userPrompt = `Here's the Product Requirements Document (PRD) to break down into approximately ${numTasks} tasks, starting IDs from ${nextId}:\n\n${prdContent}\n\n
+		const userPrompt = `Here's the Product Requirements Document (PRD) to break down into approximately ${numTasks} tasks, starting IDs from ${nextId}:${research ? '\n\nRemember to thoroughly research current best practices and technologies before task breakdown to provide specific, actionable implementation details.' : ''}\n\n${prdContent}\n\n
 
 		Return your response in this format:
 {
@@ -204,18 +222,22 @@ Guidelines:
 }`;
 
 		// Call the unified AI service
-		report('Calling AI service to generate tasks from PRD...', 'info');
+		report(
+			`Calling AI service to generate tasks from PRD${research ? ' with research-backed analysis' : ''}...`,
+			'info'
+		);
 
-		// Call generateObjectService with the CORRECT schema
+		// Call generateObjectService with the CORRECT schema and additional telemetry params
-		const generatedData = await generateObjectService({
+		aiServiceResponse = await generateObjectService({
-			role: 'main',
+			role: research ? 'research' : 'main', // Use research role if flag is set
 			session: session,
 			projectRoot: projectRoot,
 			schema: prdResponseSchema,
 			objectName: 'tasks_data',
 			systemPrompt: systemPrompt,
 			prompt: userPrompt,
-			reportProgress
+			commandName: 'parse-prd',
+			outputType: isMCP ? 'mcp' : 'cli'
 		});
 
 		// Create the directory if it doesn't exist
@@ -223,12 +245,34 @@ Guidelines:
 		if (!fs.existsSync(tasksDir)) {
 			fs.mkdirSync(tasksDir, { recursive: true });
 		}
-		logFn.success('Successfully parsed PRD via AI service.'); // Assumes generateObjectService validated
+		logFn.success(
+			`Successfully parsed PRD via AI service${research ? ' with research-backed analysis' : ''}.`
+		);
 
 		// Validate and Process Tasks
+		// const generatedData = aiServiceResponse?.mainResult?.object;
+
+		// Robustly get the actual AI-generated object
+		let generatedData = null;
+		if (aiServiceResponse?.mainResult) {
+			if (
+				typeof aiServiceResponse.mainResult === 'object' &&
+				aiServiceResponse.mainResult !== null &&
+				'tasks' in aiServiceResponse.mainResult
+			) {
+				// If mainResult itself is the object with a 'tasks' property
+				generatedData = aiServiceResponse.mainResult;
+			} else if (
+				typeof aiServiceResponse.mainResult.object === 'object' &&
+				aiServiceResponse.mainResult.object !== null &&
+				'tasks' in aiServiceResponse.mainResult.object
+			) {
+				// If mainResult.object is the object with a 'tasks' property
+				generatedData = aiServiceResponse.mainResult.object;
+			}
+		}
+
 		if (!generatedData || !Array.isArray(generatedData.tasks)) {
-			// This error *shouldn't* happen if generateObjectService enforced prdResponseSchema
-			// But keep it as a safeguard
 			logFn.error(
 				`Internal Error: generateObjectService returned unexpected data structure: ${JSON.stringify(generatedData)}`
 			);
@@ -265,36 +309,27 @@ Guidelines:
 				);
 		});
 
-		const allTasks = useAppend
+		const finalTasks = append
 			? [...existingTasks, ...processedNewTasks]
 			: processedNewTasks;
+		const outputData = { tasks: finalTasks };
 
-		const finalTaskData = { tasks: allTasks }; // Use the combined list
+		// Write the final tasks to the file
-
+		writeJSON(tasksPath, outputData);
-		// Write the tasks to the file
-		writeJSON(tasksPath, finalTaskData);
 		report(
-			`Successfully wrote ${allTasks.length} total tasks to ${tasksPath} (${processedNewTasks.length} new).`,
+			`Successfully ${append ? 'appended' : 'generated'} ${processedNewTasks.length} tasks in ${tasksPath}${research ? ' with research-backed analysis' : ''}`,
 			'success'
 		);
-		report(`Tasks saved to: ${tasksPath}`, 'info');
 
-		// Generate individual task files
+		// Generate markdown task files after writing tasks.json
-		if (reportProgress && mcpLog) {
+		await generateTaskFiles(tasksPath, path.dirname(tasksPath), { mcpLog });
-			// Enable silent mode when being called from MCP server
-			enableSilentMode();
-			await generateTaskFiles(tasksPath, path.dirname(tasksPath));
-			disableSilentMode();
-		} else {
-			await generateTaskFiles(tasksPath, path.dirname(tasksPath));
-		}
 
-		// Only show success boxes for text output (CLI)
+		// Handle CLI output (e.g., success message)
 		if (outputFormat === 'text') {
 			console.log(
 				boxen(
 					chalk.green(
-						`Successfully generated ${processedNewTasks.length} new tasks. Total tasks in ${tasksPath}: ${allTasks.length}`
+						`Successfully generated ${processedNewTasks.length} new tasks${research ? ' with research-backed analysis' : ''}. Total tasks in ${tasksPath}: ${finalTasks.length}`
 					),
 					{ padding: 1, borderColor: 'green', borderStyle: 'round' }
 				)
@@ -314,9 +349,18 @@ Guidelines:
 					}
 				)
 			);
+
+			if (aiServiceResponse && aiServiceResponse.telemetryData) {
+				displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli');
+			}
 		}
 
-		return { success: true, tasks: processedNewTasks };
+		// Return telemetry data
+		return {
+			success: true,
+			tasksPath,
+			telemetryData: aiServiceResponse?.telemetryData
+		};
 	} catch (error) {
 		report(`Error parsing PRD: ${error.message}`, 'error');
 

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

@@ -3,12 +3,12 @@ import path from 'path';
 import chalk from 'chalk';
 import boxen from 'boxen';
 import Table from 'cli-table3';
-import { z } from 'zod';
 
 import {
 	getStatusWithColor,
 	startLoadingIndicator,
-	stopLoadingIndicator
+	stopLoadingIndicator,
+	displayAiUsageSummary
 } from '../ui.js';
 import {
 	log as consoleLog,
@@ -17,10 +17,7 @@ import {
 	truncate,
 	isSilentMode
 } from '../utils.js';
-import {
+import { generateTextService } from '../ai-services-unified.js';
-	generateObjectService,
-	generateTextService
-} from '../ai-services-unified.js';
 import { getDebugFlag } from '../config-manager.js';
 import generateTaskFiles from './generate-task-files.js';
 
@@ -64,7 +61,6 @@ async function updateSubtaskById(
 	try {
 		report('info', `Updating subtask ${subtaskId} with prompt: "${prompt}"`);
 
-		// Validate subtask ID format
 		if (
 			!subtaskId ||
 			typeof subtaskId !== 'string' ||
@@ -75,19 +71,16 @@ async function updateSubtaskById(
 			);
 		}
 
-		// Validate prompt
 		if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') {
 			throw new Error(
 				'Prompt cannot be empty. Please provide context for the subtask update.'
 			);
 		}
 
-		// Validate tasks file exists
 		if (!fs.existsSync(tasksPath)) {
 			throw new Error(`Tasks file not found at path: ${tasksPath}`);
 		}
 
-		// Read the tasks file
 		const data = readJSON(tasksPath);
 		if (!data || !data.tasks) {
 			throw new Error(
@@ -95,7 +88,6 @@ async function updateSubtaskById(
 			);
 		}
 
-		// Parse parent and subtask IDs
 		const [parentIdStr, subtaskIdStr] = subtaskId.split('.');
 		const parentId = parseInt(parentIdStr, 10);
 		const subtaskIdNum = parseInt(subtaskIdStr, 10);
@@ -111,7 +103,6 @@ async function updateSubtaskById(
 			);
 		}
 
-		// Find the parent task
 		const parentTask = data.tasks.find((task) => task.id === parentId);
 		if (!parentTask) {
 			throw new Error(
@@ -119,7 +110,6 @@ async function updateSubtaskById(
 			);
 		}
 
-		// Find the subtask
 		if (!parentTask.subtasks || !Array.isArray(parentTask.subtasks)) {
 			throw new Error(`Parent task ${parentId} has no subtasks.`);
 		}
@@ -135,20 +125,7 @@ async function updateSubtaskById(
 
 		const subtask = parentTask.subtasks[subtaskIndex];
 
-		const subtaskSchema = z.object({
-			id: z.number().int().positive(),
-			title: z.string(),
-			description: z.string().optional(),
-			status: z.string(),
-			dependencies: z.array(z.union([z.string(), z.number()])).optional(),
-			priority: z.string().optional(),
-			details: z.string().optional(),
-			testStrategy: z.string().optional()
-		});
-
-		// Only show UI elements for text output (CLI)
 		if (outputFormat === 'text') {
-			// Show the subtask that will be updated
 			const table = new Table({
 				head: [
 					chalk.cyan.bold('ID'),
@@ -157,13 +134,11 @@ async function updateSubtaskById(
 				],
 				colWidths: [10, 55, 10]
 			});
-
 			table.push([
 				subtaskId,
 				truncate(subtask.title, 52),
 				getStatusWithColor(subtask.status)
 			]);
-
 			console.log(
 				boxen(chalk.white.bold(`Updating Subtask #${subtaskId}`), {
 					padding: 1,
@@ -172,10 +147,7 @@ async function updateSubtaskById(
 					margin: { top: 1, bottom: 0 }
 				})
 			);
-
 			console.log(table.toString());
-
-			// Start the loading indicator - only for text output
 			loadingIndicator = startLoadingIndicator(
 				useResearch
 					? 'Updating subtask with research...'
@@ -183,15 +155,15 @@ async function updateSubtaskById(
 			);
 		}
 
-		let parsedAIResponse;
+		let generatedContentString = '';
+		let newlyAddedSnippet = '';
+		let aiServiceResponse = null;
+
 		try {
-			// --- GET PARENT & SIBLING CONTEXT ---
 			const parentContext = {
 				id: parentTask.id,
 				title: parentTask.title
-				// Avoid sending full parent description/details unless necessary
 			};
-
 			const prevSubtask =
 				subtaskIndex > 0
 					? {
@@ -200,7 +172,6 @@ async function updateSubtaskById(
 							status: parentTask.subtasks[subtaskIndex - 1].status
 						}
 					: null;
-
 			const nextSubtask =
 				subtaskIndex < parentTask.subtasks.length - 1
 					? {
@@ -214,154 +185,123 @@ async function updateSubtaskById(
 Parent Task: ${JSON.stringify(parentContext)}
 ${prevSubtask ? `Previous Subtask: ${JSON.stringify(prevSubtask)}` : ''}
 ${nextSubtask ? `Next Subtask: ${JSON.stringify(nextSubtask)}` : ''}
+Current Subtask Details (for context only):\n${subtask.details || '(No existing details)'}
 `;
 
-			const systemPrompt = `You are an AI assistant updating a parent task's subtask. This subtask will be part of a larger parent task and will be used to direct AI agents to complete the subtask. Your goal is to GENERATE new, relevant information based on the user's request (which may be high-level, mid-level or low-level) and APPEND it to the existing subtask 'details' field, wrapped in specific XML-like tags with an ISO 8601 timestamp. Intelligently determine the level of detail to include based on the user's request. Some requests are meant simply to update the subtask with some mid-implementation details, while others are meant to update the subtask with a detailed plan or strategy.
+			const systemPrompt = `You are an AI assistant helping to update a subtask. You will be provided with the subtask's existing details, context about its parent and sibling tasks, and a user request string.
 
-Context Provided:
+Your Goal: Based *only* on the user's request and all the provided context (including existing details if relevant to the request), GENERATE the new text content that should be added to the subtask's details.
-- The current subtask object.
+Focus *only* on generating the substance of the update.
-- Basic info about the parent task (ID, title).
-- Basic info about the immediately preceding subtask (ID, title, status), if it exists.
-- Basic info about the immediately succeeding subtask (ID, title, status), if it exists.
-- A user request string.
 
-Guidelines:
+Output Requirements:
-1. Analyze the user request considering the provided subtask details AND the context of the parent and sibling tasks.
+1. Return *only* the newly generated text content as a plain string. Do NOT return a JSON object or any other structured data.
-2. GENERATE new, relevant text content that should be added to the 'details' field. Focus *only* on the substance of the update based on the user request and context. Do NOT add timestamps or any special formatting yourself. Avoid over-engineering the details, provide .
+2. Your string response should NOT include any of the subtask's original details, unless the user's request explicitly asks to rephrase, summarize, or directly modify existing text.
-3. Update the 'details' field in the subtask object with the GENERATED text content. It's okay if this overwrites previous details in the object you return, as the calling code will handle the final appending.
+3. Do NOT include any timestamps, XML-like tags, markdown, or any other special formatting in your string response.
-4. Return the *entire* updated subtask object (with your generated content in the 'details' field) as a valid JSON object conforming to the provided schema. Do NOT return explanations or markdown formatting.`;
+4. Ensure the generated text is concise yet complete for the update based on the user request. Avoid conversational fillers or explanations about what you are doing (e.g., do not start with "Okay, here's the update...").`;
 
-			const subtaskDataString = JSON.stringify(subtask, null, 2);
+			// Pass the existing subtask.details in the user prompt for the AI's context.
-			// Updated user prompt including context
+			const userPrompt = `Task Context:\n${contextString}\n\nUser Request: "${prompt}"\n\nBased on the User Request and all the Task Context (including current subtask details provided above), what is the new information or text that should be appended to this subtask's details? Return ONLY this new text as a plain string.`;
-			const userPrompt = `Task Context:\n${contextString}\nCurrent Subtask:\n${subtaskDataString}\n\nUser Request: "${prompt}"\n\nPlease GENERATE new, relevant text content for the 'details' field based on the user request and the provided context. Return the entire updated subtask object as a valid JSON object matching the schema, with the newly generated text placed in the 'details' field.`;
-			// --- END UPDATED PROMPTS ---
 
-			// Call Unified AI Service using generateObjectService
 			const role = useResearch ? 'research' : 'main';
-			report('info', `Using AI object service with role: ${role}`);
+			report('info', `Using AI text service with role: ${role}`);
 
-			parsedAIResponse = await generateObjectService({
+			aiServiceResponse = await generateTextService({
 				prompt: userPrompt,
 				systemPrompt: systemPrompt,
-				schema: subtaskSchema,
-				objectName: 'updatedSubtask',
 				role,
 				session,
 				projectRoot,
-				maxRetries: 2
+				maxRetries: 2,
+				commandName: 'update-subtask',
+				outputType: isMCP ? 'mcp' : 'cli'
 			});
-			report(
+
-				'success',
+			if (
-				'Successfully received object response from AI service'
+				aiServiceResponse &&
-			);
+				aiServiceResponse.mainResult &&
+				typeof aiServiceResponse.mainResult === 'string'
+			) {
+				generatedContentString = aiServiceResponse.mainResult;
+			} else {
+				generatedContentString = '';
+				report(
+					'warn',
+					'AI service response did not contain expected text string.'
+				);
+			}
 
 			if (outputFormat === 'text' && loadingIndicator) {
 				stopLoadingIndicator(loadingIndicator);
 				loadingIndicator = null;
 			}
-
-			if (!parsedAIResponse || typeof parsedAIResponse !== 'object') {
-				throw new Error('AI did not return a valid object.');
-			}
-
-			report(
-				'success',
-				`Successfully generated object using AI role: ${role}.`
-			);
 		} catch (aiError) {
 			report('error', `AI service call failed: ${aiError.message}`);
 			if (outputFormat === 'text' && loadingIndicator) {
-				stopLoadingIndicator(loadingIndicator); // Ensure stop on error
+				stopLoadingIndicator(loadingIndicator);
 				loadingIndicator = null;
 			}
 			throw aiError;
 		}
 
-		// --- TIMESTAMP & FORMATTING LOGIC (Handled Locally) ---
+		if (generatedContentString && generatedContentString.trim()) {
-		// Extract only the generated content from the AI's response details field.
+			// Check if the string is not empty
-		const generatedContent = parsedAIResponse.details || ''; // Default to empty string
+			const timestamp = new Date().toISOString();
+			const formattedBlock = `<info added on ${timestamp}>\n${generatedContentString.trim()}\n</info added on ${timestamp}>`;
+			newlyAddedSnippet = formattedBlock; // <--- ADD THIS LINE: Store for display
 
-		if (generatedContent.trim()) {
-			// Generate timestamp locally
-			const timestamp = new Date().toISOString(); // <<< Local Timestamp
-
-			// Format the content with XML-like tags and timestamp LOCALLY
-			const formattedBlock = `<info added on ${timestamp}>\n${generatedContent.trim()}\n</info added on ${timestamp}>`; // <<< Local Formatting
-
-			// Append the formatted block to the *original* subtask details
 			subtask.details =
-				(subtask.details ? subtask.details + '\n' : '') + formattedBlock; // <<< Local Appending
+				(subtask.details ? subtask.details + '\n' : '') + formattedBlock;
-			report(
-				'info',
-				'Appended timestamped, formatted block with AI-generated content to subtask.details.'
-			);
 		} else {
 			report(
 				'warn',
-				'AI response object did not contain generated content in the "details" field. Original details remain unchanged.'
+				'AI response was empty or whitespace after trimming. Original details remain unchanged.'
 			);
+			newlyAddedSnippet = 'No new details were added by the AI.';
 		}
-		// --- END TIMESTAMP & FORMATTING LOGIC ---
 
-		// Get a reference to the subtask *after* its details have been updated
+		const updatedSubtask = parentTask.subtasks[subtaskIndex];
-		const updatedSubtask = parentTask.subtasks[subtaskIndex]; // subtask === updatedSubtask now
 
-		report('info', 'Updated subtask details locally after AI generation.');
-		// --- END UPDATE SUBTASK ---
-
-		// Only show debug info for text output (CLI)
 		if (outputFormat === 'text' && getDebugFlag(session)) {
 			console.log(
 				'>>> DEBUG: Subtask details AFTER AI update:',
-				updatedSubtask.details // Use updatedSubtask
+				updatedSubtask.details
 			);
 		}
 
-		// Description update logic (keeping as is for now)
 		if (updatedSubtask.description) {
-			// Use updatedSubtask
 			if (prompt.length < 100) {
 				if (outputFormat === 'text' && getDebugFlag(session)) {
 					console.log(
 						'>>> DEBUG: Subtask description BEFORE append:',
-						updatedSubtask.description // Use updatedSubtask
+						updatedSubtask.description
 					);
 				}
-				updatedSubtask.description += ` [Updated: ${new Date().toLocaleDateString()}]`; // Use updatedSubtask
+				updatedSubtask.description += ` [Updated: ${new Date().toLocaleDateString()}]`;
 				if (outputFormat === 'text' && getDebugFlag(session)) {
 					console.log(
 						'>>> DEBUG: Subtask description AFTER append:',
-						updatedSubtask.description // Use updatedSubtask
+						updatedSubtask.description
 					);
 				}
 			}
 		}
 
-		// Only show debug info for text output (CLI)
 		if (outputFormat === 'text' && getDebugFlag(session)) {
 			console.log('>>> DEBUG: About to call writeJSON with updated data...');
 		}
-
-		// Write the updated tasks to the file (parentTask already contains the updated subtask)
 		writeJSON(tasksPath, data);
-
-		// Only show debug info for text output (CLI)
 		if (outputFormat === 'text' && getDebugFlag(session)) {
 			console.log('>>> DEBUG: writeJSON call completed.');
 		}
 
 		report('success', `Successfully updated subtask ${subtaskId}`);
-
-		// Generate individual task files
 		await generateTaskFiles(tasksPath, path.dirname(tasksPath));
 
-		// Stop indicator before final console output - only for text output (CLI)
 		if (outputFormat === 'text') {
 			if (loadingIndicator) {
 				stopLoadingIndicator(loadingIndicator);
 				loadingIndicator = null;
 			}
-
 			console.log(
 				boxen(
 					chalk.green(`Successfully updated subtask #${subtaskId}`) +
@@ -370,31 +310,30 @@ Guidelines:
 						' ' +
 						updatedSubtask.title +
 						'\n\n' +
-						// Update the display to show the new details field
+						chalk.white.bold('Newly Added Snippet:') +
-						chalk.white.bold('Updated Details:') +
 						'\n' +
-						chalk.white(truncate(updatedSubtask.details || '', 500, true)), // Use updatedSubtask
+						chalk.white(newlyAddedSnippet),
 					{ padding: 1, borderColor: 'green', borderStyle: 'round' }
 				)
 			);
 		}
 
-		return updatedSubtask; // Return the modified subtask object
+		if (outputFormat === 'text' && aiServiceResponse.telemetryData) {
+			displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli');
+		}
+
+		return {
+			updatedSubtask: updatedSubtask,
+			telemetryData: aiServiceResponse.telemetryData
+		};
 	} catch (error) {
-		// Outer catch block handles final errors after loop/attempts
-		// Stop indicator on error - only for text output (CLI)
 		if (outputFormat === 'text' && loadingIndicator) {
 			stopLoadingIndicator(loadingIndicator);
 			loadingIndicator = null;
 		}
-
 		report('error', `Error updating subtask: ${error.message}`);
-
-		// Only show error UI for text output (CLI)
 		if (outputFormat === 'text') {
 			console.error(chalk.red(`Error: ${error.message}`));
-
-			// Provide helpful error messages based on error type
 			if (error.message?.includes('ANTHROPIC_API_KEY')) {
 				console.log(
 					chalk.yellow('\nTo fix this issue, set your Anthropic API key:')
@@ -409,7 +348,6 @@ Guidelines:
 					'  2. Or run without the research flag: task-master update-subtask --id=<id> --prompt="..."'
 				);
 			} else if (error.message?.includes('overloaded')) {
-				// Catch final overload error
 				console.log(
 					chalk.yellow(
 						'\nAI model overloaded, and fallback failed or was unavailable:'
@@ -417,7 +355,6 @@ Guidelines:
 				);
 				console.log('  1. Try again in a few minutes.');
 				console.log('  2. Ensure PERPLEXITY_API_KEY is set for fallback.');
-				console.log('  3. Consider breaking your prompt into smaller updates.');
 			} else if (error.message?.includes('not found')) {
 				console.log(chalk.yellow('\nTo fix this issue:'));
 				console.log(
@@ -426,22 +363,22 @@ Guidelines:
 				console.log(
 					'  2. Use a valid subtask ID with the --id parameter in format "parentId.subtaskId"'
 				);
-			} else if (error.message?.includes('empty stream response')) {
+			} else if (
+				error.message?.includes('empty stream response') ||
+				error.message?.includes('AI did not return a valid text string')
+			) {
 				console.log(
 					chalk.yellow(
-						'\nThe AI model returned an empty response. This might be due to the prompt or API issues. Try rephrasing or trying again later.'
+						'\nThe AI model returned an empty or invalid response. This might be due to the prompt or API issues. Try rephrasing or trying again later.'
 					)
 				);
 			}
-
 			if (getDebugFlag(session)) {
-				// Use getter
 				console.error(error);
 			}
 		} else {
-			throw error; // Re-throw for JSON output
+			throw error;
 		}
-
 		return null;
 	}
 }

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

@@ -16,7 +16,8 @@ import {
 import {
 	getStatusWithColor,
 	startLoadingIndicator,
-	stopLoadingIndicator
+	stopLoadingIndicator,
+	displayAiUsageSummary
 } from '../ui.js';
 
 import { generateTextService } from '../ai-services-unified.js';
@@ -94,10 +95,6 @@ function parseUpdatedTaskFromText(text, expectedTaskId, logFn, isMCP) {
 			// It worked! Use this as the primary cleaned response.
 			cleanedResponse = potentialJsonFromBraces;
 			parseMethodUsed = 'braces';
-			report(
-				'info',
-				'Successfully parsed JSON content extracted between first { and last }.'
-			);
 		} catch (e) {
 			report(
 				'info',
@@ -376,29 +373,125 @@ The changes described in the prompt should be thoughtfully applied to make the t
 		const userPrompt = `Here is the task to update:\n${taskDataString}\n\nPlease update this task based on the following new context:\n${prompt}\n\nIMPORTANT: In the task JSON above, any subtasks with "status": "done" or "status": "completed" should be preserved exactly as is. Build your changes around these completed items.\n\nReturn only the updated task as a valid JSON object.`;
 		// --- End Build Prompts ---
 
-		let updatedTask;
 		let loadingIndicator = null;
-		if (outputFormat === 'text') {
+		let aiServiceResponse = null;
+
+		if (!isMCP && outputFormat === 'text') {
 			loadingIndicator = startLoadingIndicator(
 				useResearch ? 'Updating task with research...\n' : 'Updating task...\n'
 			);
 		}
 
-		let responseText = '';
 		try {
-			// --- Call Unified AI Service (generateTextService) ---
+			const serviceRole = useResearch ? 'research' : 'main';
-			const role = useResearch ? 'research' : 'main';
+			aiServiceResponse = await generateTextService({
-			report('info', `Using AI service with role: ${role}`);
+				role: serviceRole,
-
+				session: session,
-			responseText = await generateTextService({
+				projectRoot: projectRoot,
-				prompt: userPrompt,
 				systemPrompt: systemPrompt,
-				role,
+				prompt: userPrompt,
-				session,
+				commandName: 'update-task',
-				projectRoot
+				outputType: isMCP ? 'mcp' : 'cli'
 			});
-			report('success', 'Successfully received text response from AI service');
+
-			// --- End AI Service Call ---
+			if (loadingIndicator)
+				stopLoadingIndicator(loadingIndicator, 'AI update complete.');
+
+			// Use mainResult (text) for parsing
+			const updatedTask = parseUpdatedTaskFromText(
+				aiServiceResponse.mainResult,
+				taskId,
+				logFn,
+				isMCP
+			);
+
+			// --- Task Validation/Correction (Keep existing logic) ---
+			if (!updatedTask || typeof updatedTask !== 'object')
+				throw new Error('Received invalid task object from AI.');
+			if (!updatedTask.title || !updatedTask.description)
+				throw new Error('Updated task missing required fields.');
+			// Preserve ID if AI changed it
+			if (updatedTask.id !== taskId) {
+				report('warn', `AI changed task ID. Restoring original ID ${taskId}.`);
+				updatedTask.id = taskId;
+			}
+			// Preserve status if AI changed it
+			if (
+				updatedTask.status !== taskToUpdate.status &&
+				!prompt.toLowerCase().includes('status')
+			) {
+				report(
+					'warn',
+					`AI changed task status. Restoring original status '${taskToUpdate.status}'.`
+				);
+				updatedTask.status = taskToUpdate.status;
+			}
+			// Preserve completed subtasks (Keep existing logic)
+			if (taskToUpdate.subtasks?.length > 0) {
+				if (!updatedTask.subtasks) {
+					report(
+						'warn',
+						'Subtasks removed by AI. Restoring original subtasks.'
+					);
+					updatedTask.subtasks = taskToUpdate.subtasks;
+				} else {
+					const completedOriginal = taskToUpdate.subtasks.filter(
+						(st) => st.status === 'done' || st.status === 'completed'
+					);
+					completedOriginal.forEach((compSub) => {
+						const updatedSub = updatedTask.subtasks.find(
+							(st) => st.id === compSub.id
+						);
+						if (
+							!updatedSub ||
+							JSON.stringify(updatedSub) !== JSON.stringify(compSub)
+						) {
+							report(
+								'warn',
+								`Completed subtask ${compSub.id} was modified or removed. Restoring.`
+							);
+							// Remove potentially modified version
+							updatedTask.subtasks = updatedTask.subtasks.filter(
+								(st) => st.id !== compSub.id
+							);
+							// Add back original
+							updatedTask.subtasks.push(compSub);
+						}
+					});
+					// Deduplicate just in case
+					const subtaskIds = new Set();
+					updatedTask.subtasks = updatedTask.subtasks.filter((st) => {
+						if (!subtaskIds.has(st.id)) {
+							subtaskIds.add(st.id);
+							return true;
+						}
+						report('warn', `Duplicate subtask ID ${st.id} removed.`);
+						return false;
+					});
+				}
+			}
+			// --- End Task Validation/Correction ---
+
+			// --- Update Task Data (Keep existing) ---
+			data.tasks[taskIndex] = updatedTask;
+			// --- End Update Task Data ---
+
+			// --- Write File and Generate (Unchanged) ---
+			writeJSON(tasksPath, data);
+			report('success', `Successfully updated task ${taskId}`);
+			await generateTaskFiles(tasksPath, path.dirname(tasksPath));
+			// --- End Write File ---
+
+			// --- Display CLI Telemetry ---
+			if (outputFormat === 'text' && aiServiceResponse.telemetryData) {
+				displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli'); // <<< ADD display
+			}
+
+			// --- Return Success with Telemetry ---
+			return {
+				updatedTask: updatedTask, // Return the updated task object
+				telemetryData: aiServiceResponse.telemetryData // <<< ADD telemetryData
+			};
 		} catch (error) {
 			// Catch errors from generateTextService
 			if (loadingIndicator) stopLoadingIndicator(loadingIndicator);
@@ -407,114 +500,7 @@ The changes described in the prompt should be thoughtfully applied to make the t
 				report('error', 'Please ensure API keys are configured correctly.');
 			}
 			throw error; // Re-throw error
-		} finally {
-			if (loadingIndicator) stopLoadingIndicator(loadingIndicator);
 		}
-
-		// --- Parse and Validate Response ---
-		try {
-			// Pass logFn and isMCP flag to the parser
-			updatedTask = parseUpdatedTaskFromText(
-				responseText,
-				taskId,
-				logFn,
-				isMCP
-			);
-		} catch (parseError) {
-			report(
-				'error',
-				`Failed to parse updated task from AI response: ${parseError.message}`
-			);
-			if (getDebugFlag(session)) {
-				report('error', `Raw AI Response:\n${responseText}`);
-			}
-			throw new Error(
-				`Failed to parse valid updated task from AI response: ${parseError.message}`
-			);
-		}
-		// --- End Parse/Validate ---
-
-		// --- Task Validation/Correction (Keep existing logic) ---
-		if (!updatedTask || typeof updatedTask !== 'object')
-			throw new Error('Received invalid task object from AI.');
-		if (!updatedTask.title || !updatedTask.description)
-			throw new Error('Updated task missing required fields.');
-		// Preserve ID if AI changed it
-		if (updatedTask.id !== taskId) {
-			report('warn', `AI changed task ID. Restoring original ID ${taskId}.`);
-			updatedTask.id = taskId;
-		}
-		// Preserve status if AI changed it
-		if (
-			updatedTask.status !== taskToUpdate.status &&
-			!prompt.toLowerCase().includes('status')
-		) {
-			report(
-				'warn',
-				`AI changed task status. Restoring original status '${taskToUpdate.status}'.`
-			);
-			updatedTask.status = taskToUpdate.status;
-		}
-		// Preserve completed subtasks (Keep existing logic)
-		if (taskToUpdate.subtasks?.length > 0) {
-			if (!updatedTask.subtasks) {
-				report('warn', 'Subtasks removed by AI. Restoring original subtasks.');
-				updatedTask.subtasks = taskToUpdate.subtasks;
-			} else {
-				const completedOriginal = taskToUpdate.subtasks.filter(
-					(st) => st.status === 'done' || st.status === 'completed'
-				);
-				completedOriginal.forEach((compSub) => {
-					const updatedSub = updatedTask.subtasks.find(
-						(st) => st.id === compSub.id
-					);
-					if (
-						!updatedSub ||
-						JSON.stringify(updatedSub) !== JSON.stringify(compSub)
-					) {
-						report(
-							'warn',
-							`Completed subtask ${compSub.id} was modified or removed. Restoring.`
-						);
-						// Remove potentially modified version
-						updatedTask.subtasks = updatedTask.subtasks.filter(
-							(st) => st.id !== compSub.id
-						);
-						// Add back original
-						updatedTask.subtasks.push(compSub);
-					}
-				});
-				// Deduplicate just in case
-				const subtaskIds = new Set();
-				updatedTask.subtasks = updatedTask.subtasks.filter((st) => {
-					if (!subtaskIds.has(st.id)) {
-						subtaskIds.add(st.id);
-						return true;
-					}
-					report('warn', `Duplicate subtask ID ${st.id} removed.`);
-					return false;
-				});
-			}
-		}
-		// --- End Task Validation/Correction ---
-
-		// --- Update Task Data (Keep existing) ---
-		data.tasks[taskIndex] = updatedTask;
-		// --- End Update Task Data ---
-
-		// --- Write File and Generate (Keep existing) ---
-		writeJSON(tasksPath, data);
-		report('success', `Successfully updated task ${taskId}`);
-		await generateTaskFiles(tasksPath, path.dirname(tasksPath));
-		// --- End Write File ---
-
-		// --- Final CLI Output (Keep existing) ---
-		if (outputFormat === 'text') {
-			/* ... success boxen ... */
-		}
-		// --- End Final CLI Output ---
-
-		return updatedTask; // Return the updated task
 	} catch (error) {
 		// General error catch
 		// --- General Error Handling (Keep existing) ---

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

@@ -15,7 +15,8 @@ import {
 import {
 	getStatusWithColor,
 	startLoadingIndicator,
-	stopLoadingIndicator
+	stopLoadingIndicator,
+	displayAiUsageSummary
 } from '../ui.js';
 
 import { getDebugFlag } from '../config-manager.js';
@@ -93,10 +94,6 @@ function parseUpdatedTasksFromText(text, expectedCount, logFn, isMCP) {
 			// It worked! Use this as the primary cleaned response.
 			cleanedResponse = potentialJsonFromArray;
 			parseMethodUsed = 'brackets';
-			report(
-				'info',
-				'Successfully parsed JSON content extracted between first [ and last ].'
-			);
 		} catch (e) {
 			report(
 				'info',
@@ -350,31 +347,100 @@ The changes described in the prompt should be applied to ALL tasks in the list.`
 		const userPrompt = `Here are the tasks to update:\n${taskDataString}\n\nPlease update these tasks based on the following new context:\n${prompt}\n\nIMPORTANT: In the tasks JSON above, any subtasks with "status": "done" or "status": "completed" should be preserved exactly as is. Build your changes around these completed items.\n\nReturn only the updated tasks as a valid JSON array.`;
 		// --- End Build Prompts ---
 
+		// --- AI Call ---
 		let loadingIndicator = null;
-		if (outputFormat === 'text') {
+		let aiServiceResponse = null;
-			loadingIndicator = startLoadingIndicator('Updating tasks...\n');
+
+		if (!isMCP && outputFormat === 'text') {
+			loadingIndicator = startLoadingIndicator('Updating tasks with AI...\n');
 		}
 
-		let responseText = '';
-		let updatedTasks;
-
 		try {
-			// --- Call Unified AI Service ---
+			// Determine role based on research flag
-			const role = useResearch ? 'research' : 'main';
+			const serviceRole = useResearch ? 'research' : 'main';
-			if (isMCP) logFn.info(`Using AI service with role: ${role}`);
-			else logFn('info', `Using AI service with role: ${role}`);
 
-			responseText = await generateTextService({
+			// Call the unified AI service
-				prompt: userPrompt,
+			aiServiceResponse = await generateTextService({
+				role: serviceRole,
+				session: session,
+				projectRoot: projectRoot,
 				systemPrompt: systemPrompt,
-				role,
+				prompt: userPrompt,
-				session,
+				commandName: 'update-tasks',
-				projectRoot
+				outputType: isMCP ? 'mcp' : 'cli'
 			});
-			if (isMCP) logFn.info('Successfully received text response');
+
+			if (loadingIndicator)
+				stopLoadingIndicator(loadingIndicator, 'AI update complete.');
+
+			// Use the mainResult (text) for parsing
+			const parsedUpdatedTasks = parseUpdatedTasksFromText(
+				aiServiceResponse.mainResult,
+				tasksToUpdate.length,
+				logFn,
+				isMCP
+			);
+
+			// --- Update Tasks Data (Unchanged) ---
+			if (!Array.isArray(parsedUpdatedTasks)) {
+				// Should be caught by parser, but extra check
+				throw new Error(
+					'Parsed AI response for updated tasks was not an array.'
+				);
+			}
+			if (isMCP)
+				logFn.info(
+					`Received ${parsedUpdatedTasks.length} updated tasks from AI.`
+				);
 			else
-				logFn('success', 'Successfully received text response via AI service');
+				logFn(
-			// --- End AI Service Call ---
+					'info',
+					`Received ${parsedUpdatedTasks.length} updated tasks from AI.`
+				);
+			// Create a map for efficient lookup
+			const updatedTasksMap = new Map(
+				parsedUpdatedTasks.map((task) => [task.id, task])
+			);
+
+			let actualUpdateCount = 0;
+			data.tasks.forEach((task, index) => {
+				if (updatedTasksMap.has(task.id)) {
+					// Only update if the task was part of the set sent to AI
+					data.tasks[index] = updatedTasksMap.get(task.id);
+					actualUpdateCount++;
+				}
+			});
+			if (isMCP)
+				logFn.info(
+					`Applied updates to ${actualUpdateCount} tasks in the dataset.`
+				);
+			else
+				logFn(
+					'info',
+					`Applied updates to ${actualUpdateCount} tasks in the dataset.`
+				);
+
+			writeJSON(tasksPath, data);
+			if (isMCP)
+				logFn.info(
+					`Successfully updated ${actualUpdateCount} tasks in ${tasksPath}`
+				);
+			else
+				logFn(
+					'success',
+					`Successfully updated ${actualUpdateCount} tasks in ${tasksPath}`
+				);
+			await generateTaskFiles(tasksPath, path.dirname(tasksPath));
+
+			if (outputFormat === 'text' && aiServiceResponse.telemetryData) {
+				displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli');
+			}
+
+			return {
+				success: true,
+				updatedTasks: parsedUpdatedTasks,
+				telemetryData: aiServiceResponse.telemetryData
+			};
 		} catch (error) {
 			if (loadingIndicator) stopLoadingIndicator(loadingIndicator);
 			if (isMCP) logFn.error(`Error during AI service call: ${error.message}`);
@@ -390,98 +456,10 @@ The changes described in the prompt should be applied to ALL tasks in the list.`
 						'Please ensure API keys are configured correctly in .env or mcp.json.'
 					);
 			}
-			throw error; // Re-throw error
+			throw error;
 		} finally {
 			if (loadingIndicator) stopLoadingIndicator(loadingIndicator);
 		}
-
-		// --- Parse and Validate Response ---
-		try {
-			updatedTasks = parseUpdatedTasksFromText(
-				responseText,
-				tasksToUpdate.length,
-				logFn,
-				isMCP
-			);
-		} catch (parseError) {
-			if (isMCP)
-				logFn.error(
-					`Failed to parse updated tasks from AI response: ${parseError.message}`
-				);
-			else
-				logFn(
-					'error',
-					`Failed to parse updated tasks from AI response: ${parseError.message}`
-				);
-			if (getDebugFlag(session)) {
-				if (isMCP) logFn.error(`Raw AI Response:\n${responseText}`);
-				else logFn('error', `Raw AI Response:\n${responseText}`);
-			}
-			throw new Error(
-				`Failed to parse valid updated tasks from AI response: ${parseError.message}`
-			);
-		}
-		// --- End Parse/Validate ---
-
-		// --- Update Tasks Data (Unchanged) ---
-		if (!Array.isArray(updatedTasks)) {
-			// Should be caught by parser, but extra check
-			throw new Error('Parsed AI response for updated tasks was not an array.');
-		}
-		if (isMCP)
-			logFn.info(`Received ${updatedTasks.length} updated tasks from AI.`);
-		else
-			logFn('info', `Received ${updatedTasks.length} updated tasks from AI.`);
-		// Create a map for efficient lookup
-		const updatedTasksMap = new Map(
-			updatedTasks.map((task) => [task.id, task])
-		);
-
-		// Iterate through the original data and update based on the map
-		let actualUpdateCount = 0;
-		data.tasks.forEach((task, index) => {
-			if (updatedTasksMap.has(task.id)) {
-				// Only update if the task was part of the set sent to AI
-				data.tasks[index] = updatedTasksMap.get(task.id);
-				actualUpdateCount++;
-			}
-		});
-		if (isMCP)
-			logFn.info(
-				`Applied updates to ${actualUpdateCount} tasks in the dataset.`
-			);
-		else
-			logFn(
-				'info',
-				`Applied updates to ${actualUpdateCount} tasks in the dataset.`
-			);
-		// --- End Update Tasks Data ---
-
-		// --- Write File and Generate (Unchanged) ---
-		writeJSON(tasksPath, data);
-		if (isMCP)
-			logFn.info(
-				`Successfully updated ${actualUpdateCount} tasks in ${tasksPath}`
-			);
-		else
-			logFn(
-				'success',
-				`Successfully updated ${actualUpdateCount} tasks in ${tasksPath}`
-			);
-		await generateTaskFiles(tasksPath, path.dirname(tasksPath));
-		// --- End Write File ---
-
-		// --- Final CLI Output (Unchanged) ---
-		if (outputFormat === 'text') {
-			console.log(
-				boxen(chalk.green(`Successfully updated ${actualUpdateCount} tasks`), {
-					padding: 1,
-					borderColor: 'green',
-					borderStyle: 'round'
-				})
-			);
-		}
-		// --- End Final CLI Output ---
 	} catch (error) {
 		// --- General Error Handling (Unchanged) ---
 		if (isMCP) logFn.error(`Error updating tasks: ${error.message}`);

scripts/modules/ui.js

@@ -870,8 +870,11 @@ async function displayNextTask(tasksPath, complexityReportPath = null) {
 		);
 	}
 
-	// Show subtasks if they exist
+	// Determine if the nextTask is a subtask
-	if (nextTask.subtasks && nextTask.subtasks.length > 0) {
+	const isSubtask = !!nextTask.parentId;
+
+	// Show subtasks if they exist (only for parent tasks)
+	if (!isSubtask && nextTask.subtasks && nextTask.subtasks.length > 0) {
 		console.log(
 			boxen(chalk.white.bold('Subtasks'), {
 				padding: { top: 0, bottom: 0, left: 1, right: 1 },
@@ -971,8 +974,10 @@ async function displayNextTask(tasksPath, complexityReportPath = null) {
 		});
 
 		console.log(subtaskTable.toString());
-	} else {
+	}
-		// Suggest expanding if no subtasks
+
+	// Suggest expanding if no subtasks (only for parent tasks without subtasks)
+	if (!isSubtask && (!nextTask.subtasks || nextTask.subtasks.length === 0)) {
 		console.log(
 			boxen(
 				chalk.yellow('No subtasks found. Consider breaking down this task:') +
@@ -991,22 +996,30 @@ async function displayNextTask(tasksPath, complexityReportPath = null) {
 	}
 
 	// Show action suggestions
+	let suggestedActionsContent = chalk.white.bold('Suggested Actions:') + '\n';
+	if (isSubtask) {
+		// Suggested actions for a subtask
+		suggestedActionsContent +=
+			`${chalk.cyan('1.')} Mark as in-progress: ${chalk.yellow(`task-master set-status --id=${nextTask.id} --status=in-progress`)}\n` +
+			`${chalk.cyan('2.')} Mark as done when completed: ${chalk.yellow(`task-master set-status --id=${nextTask.id} --status=done`)}\n` +
+			`${chalk.cyan('3.')} View parent task: ${chalk.yellow(`task-master show --id=${nextTask.parentId}`)}`;
+	} else {
+		// Suggested actions for a parent task
+		suggestedActionsContent +=
+			`${chalk.cyan('1.')} Mark as in-progress: ${chalk.yellow(`task-master set-status --id=${nextTask.id} --status=in-progress`)}\n` +
+			`${chalk.cyan('2.')} Mark as done when completed: ${chalk.yellow(`task-master set-status --id=${nextTask.id} --status=done`)}\n` +
+			(nextTask.subtasks && nextTask.subtasks.length > 0
+				? `${chalk.cyan('3.')} Update subtask status: ${chalk.yellow(`task-master set-status --id=${nextTask.id}.1 --status=done`)}` // Example: first subtask
+				: `${chalk.cyan('3.')} Break down into subtasks: ${chalk.yellow(`task-master expand --id=${nextTask.id}`)}`);
+	}
+
 	console.log(
-		boxen(
+		boxen(suggestedActionsContent, {
-			chalk.white.bold('Suggested Actions:') +
+			padding: { top: 0, bottom: 0, left: 1, right: 1 },
-				'\n' +
+			borderColor: 'green',
-				`${chalk.cyan('1.')} Mark as in-progress: ${chalk.yellow(`task-master set-status --id=${nextTask.id} --status=in-progress`)}\n` +
+			borderStyle: 'round',
-				`${chalk.cyan('2.')} Mark as done when completed: ${chalk.yellow(`task-master set-status --id=${nextTask.id} --status=done`)}\n` +
+			margin: { top: 1 }
-				(nextTask.subtasks && nextTask.subtasks.length > 0
+		})
-					? `${chalk.cyan('3.')} Update subtask status: ${chalk.yellow(`task-master set-status --id=${nextTask.id}.1 --status=done`)}`
-					: `${chalk.cyan('3.')} Break down into subtasks: ${chalk.yellow(`task-master expand --id=${nextTask.id}`)}`),
-			{
-				padding: { top: 0, bottom: 0, left: 1, right: 1 },
-				borderColor: 'green',
-				borderStyle: 'round',
-				margin: { top: 1 }
-			}
-		)
 	);
 }
 
@@ -2005,6 +2018,51 @@ function displayAvailableModels(availableModels) {
 	);
 }
 
+/**
+ * Displays AI usage telemetry summary in the CLI.
+ * @param {object} telemetryData - The telemetry data object.
+ * @param {string} outputType - 'cli' or 'mcp' (though typically only called for 'cli').
+ */
+function displayAiUsageSummary(telemetryData, outputType = 'cli') {
+	if (
+		(outputType !== 'cli' && outputType !== 'text') ||
+		!telemetryData ||
+		isSilentMode()
+	) {
+		return; // Only display for CLI and if data exists and not in silent mode
+	}
+
+	const {
+		modelUsed,
+		providerName,
+		inputTokens,
+		outputTokens,
+		totalTokens,
+		totalCost,
+		commandName
+	} = telemetryData;
+
+	let summary = chalk.bold.blue('AI Usage Summary:') + '\n';
+	summary += chalk.gray(`  Command: ${commandName}\n`);
+	summary += chalk.gray(`  Provider: ${providerName}\n`);
+	summary += chalk.gray(`  Model: ${modelUsed}\n`);
+	summary += chalk.gray(
+		`  Tokens: ${totalTokens} (Input: ${inputTokens}, Output: ${outputTokens})\n`
+	);
+	summary += chalk.gray(`  Est. Cost: $${totalCost.toFixed(6)}`);
+
+	console.log(
+		boxen(summary, {
+			padding: 1,
+			margin: { top: 1 },
+			borderColor: 'blue',
+			borderStyle: 'round',
+			title: '💡 Telemetry',
+			titleAlignment: 'center'
+		})
+	);
+}
+
 // Export UI functions
 export {
 	displayBanner,
@@ -2022,5 +2080,6 @@ export {
 	confirmTaskOverwrite,
 	displayApiKeyStatus,
 	displayModelConfiguration,
-	displayAvailableModels
+	displayAvailableModels,
+	displayAiUsageSummary
 };

scripts/modules/utils.js

@@ -60,8 +60,7 @@ function resolveEnvVariable(key, session = null, projectRoot = null) {
 
 // --- Project Root Finding Utility ---
 /**
- * Finds the project root directory by searching upwards from a given starting point
+ * Finds the project root directory by searching for marker files/directories.
- * for a marker file or directory (e.g., 'package.json', '.git').
  * @param {string} [startPath=process.cwd()] - The directory to start searching from.
  * @param {string[]} [markers=['package.json', '.git', '.taskmasterconfig']] - Marker files/dirs to look for.
  * @returns {string|null} The path to the project root directory, or null if not found.
@@ -71,27 +70,35 @@ function findProjectRoot(
 	markers = ['package.json', '.git', '.taskmasterconfig']
 ) {
 	let currentPath = path.resolve(startPath);
-	while (true) {
+	const rootPath = path.parse(currentPath).root;
-		for (const marker of markers) {
+
-			if (fs.existsSync(path.join(currentPath, marker))) {
+	while (currentPath !== rootPath) {
-				return currentPath;
+		// Check if any marker exists in the current directory
-			}
+		const hasMarker = markers.some((marker) => {
+			const markerPath = path.join(currentPath, marker);
+			return fs.existsSync(markerPath);
+		});
+
+		if (hasMarker) {
+			return currentPath;
 		}
-		const parentPath = path.dirname(currentPath);
+
-		if (parentPath === currentPath) {
+		// Move up one directory
-			// Reached the filesystem root
+		currentPath = path.dirname(currentPath);
-			return null;
-		}
-		currentPath = parentPath;
 	}
+
+	// Check the root directory as well
+	const hasMarkerInRoot = markers.some((marker) => {
+		const markerPath = path.join(rootPath, marker);
+		return fs.existsSync(markerPath);
+	});
+
+	return hasMarkerInRoot ? rootPath : null;
 }
 
 // --- Dynamic Configuration Function --- (REMOVED)
-/*
+
-function getConfig(session = null) {
+// --- Logging and Utility Functions ---
-    // ... implementation removed ...
-}
-*/
 
 // Set up logging based on log level
 const LOG_LEVELS = {
@@ -546,6 +553,61 @@ function detectCamelCaseFlags(args) {
 	return camelCaseFlags;
 }
 
+/**
+ * Aggregates an array of telemetry objects into a single summary object.
+ * @param {Array<Object>} telemetryArray - Array of telemetryData objects.
+ * @param {string} overallCommandName - The name for the aggregated command.
+ * @returns {Object|null} Aggregated telemetry object or null if input is empty.
+ */
+function aggregateTelemetry(telemetryArray, overallCommandName) {
+	if (!telemetryArray || telemetryArray.length === 0) {
+		return null;
+	}
+
+	const aggregated = {
+		timestamp: new Date().toISOString(), // Use current time for aggregation time
+		userId: telemetryArray[0].userId, // Assume userId is consistent
+		commandName: overallCommandName,
+		modelUsed: 'Multiple', // Default if models vary
+		providerName: 'Multiple', // Default if providers vary
+		inputTokens: 0,
+		outputTokens: 0,
+		totalTokens: 0,
+		totalCost: 0,
+		currency: telemetryArray[0].currency || 'USD' // Assume consistent currency or default
+	};
+
+	const uniqueModels = new Set();
+	const uniqueProviders = new Set();
+	const uniqueCurrencies = new Set();
+
+	telemetryArray.forEach((item) => {
+		aggregated.inputTokens += item.inputTokens || 0;
+		aggregated.outputTokens += item.outputTokens || 0;
+		aggregated.totalCost += item.totalCost || 0;
+		uniqueModels.add(item.modelUsed);
+		uniqueProviders.add(item.providerName);
+		uniqueCurrencies.add(item.currency || 'USD');
+	});
+
+	aggregated.totalTokens = aggregated.inputTokens + aggregated.outputTokens;
+	aggregated.totalCost = parseFloat(aggregated.totalCost.toFixed(6)); // Fix precision
+
+	if (uniqueModels.size === 1) {
+		aggregated.modelUsed = [...uniqueModels][0];
+	}
+	if (uniqueProviders.size === 1) {
+		aggregated.providerName = [...uniqueProviders][0];
+	}
+	if (uniqueCurrencies.size > 1) {
+		aggregated.currency = 'Multiple'; // Mark if currencies actually differ
+	} else if (uniqueCurrencies.size === 1) {
+		aggregated.currency = [...uniqueCurrencies][0];
+	}
+
+	return aggregated;
+}
+
 // Export all utility functions and configuration
 export {
 	LOG_LEVELS,
@@ -568,5 +630,6 @@ export {
 	isSilentMode,
 	addComplexityToTask,
 	resolveEnvVariable,
-	findProjectRoot
+	findProjectRoot,
+	aggregateTelemetry
 };

scripts/task-complexity-report.json

@@ -1,299 +1,357 @@
 {
 	"meta": {
-		"generatedAt": "2025-05-03T04:45:36.864Z",
+		"generatedAt": "2025-05-22T05:48:33.026Z",
-		"tasksAnalyzed": 36,
+		"tasksAnalyzed": 6,
+		"totalTasks": 88,
+		"analysisCount": 43,
 		"thresholdScore": 5,
 		"projectName": "Taskmaster",
-		"usedResearch": false
+		"usedResearch": true
 	},
 	"complexityAnalysis": [
 		{
 			"taskId": 24,
 			"taskTitle": "Implement AI-Powered Test Generation Command",
-			"complexityScore": 8,
+			"complexityScore": 7,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement AI-Powered Test Generation Command' task by detailing the specific steps required for AI prompt engineering, including data extraction, prompt formatting, and error handling.",
+			"expansionPrompt": "Break down the implementation of the AI-powered test generation command into detailed subtasks covering: command structure setup, AI prompt engineering, test file generation logic, integration with Claude API, and comprehensive error handling.",
-			"reasoning": "Requires AI integration, complex logic, and thorough testing. Prompt engineering and API interaction add significant complexity."
+			"reasoning": "This task involves complex integration with an AI service (Claude), requires sophisticated prompt engineering, and needs to generate structured code files. The existing 3 subtasks are a good start but could be expanded to include more detailed steps for AI integration, error handling, and test file formatting."
 		},
 		{
 			"taskId": 26,
 			"taskTitle": "Implement Context Foundation for AI Operations",
-			"complexityScore": 7,
+			"complexityScore": 6,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 4,
-			"expansionPrompt": "Expand the 'Implement Context Foundation for AI Operations' task by detailing the specific steps for integrating file reading, cursor rules, and basic context extraction into the Claude API prompts.",
+			"expansionPrompt": "The current 4 subtasks for implementing the context foundation appear comprehensive. Consider if any additional subtasks are needed for testing, documentation, or integration with existing systems.",
-			"reasoning": "Involves modifying multiple commands and integrating different context sources. Error handling and backwards compatibility are crucial."
+			"reasoning": "This task involves creating a foundation for context integration with several well-defined components. The existing 4 subtasks cover the main implementation areas (context-file flag, cursor rules integration, context extraction utility, and command handler updates). The complexity is moderate as it requires careful integration with existing systems but has clear requirements."
 		},
 		{
 			"taskId": 27,
 			"taskTitle": "Implement Context Enhancements for AI Operations",
-			"complexityScore": 8,
+			"complexityScore": 7,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 4,
-			"expansionPrompt": "Expand the 'Implement Context Enhancements for AI Operations' task by detailing the specific steps for code context extraction, task history integration, and PRD context integration, including parsing, summarization, and formatting.",
+			"expansionPrompt": "The current 4 subtasks for implementing context enhancements appear well-structured. Consider if any additional subtasks are needed for testing, documentation, or performance optimization.",
-			"reasoning": "Builds upon the previous task with more sophisticated context extraction and integration. Requires intelligent parsing and summarization."
+			"reasoning": "This task builds upon the foundation from Task #26 and adds more sophisticated context handling features. The 4 existing subtasks cover the main implementation areas (code context extraction, task history context, PRD context integration, and context formatting). The complexity is higher than the foundation task due to the need for intelligent context selection and optimization."
 		},
 		{
 			"taskId": 28,
 			"taskTitle": "Implement Advanced ContextManager System",
-			"complexityScore": 9,
+			"complexityScore": 8,
-			"recommendedSubtasks": 7,
+			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement Advanced ContextManager System' task by detailing the specific steps for creating the ContextManager class, implementing the optimization pipeline, and adding command interface enhancements, including caching and performance monitoring.",
+			"expansionPrompt": "The current 5 subtasks for implementing the advanced ContextManager system appear comprehensive. Consider if any additional subtasks are needed for testing, documentation, or backward compatibility with previous context implementations.",
-			"reasoning": "A comprehensive system requiring careful design, optimization, and testing. Involves complex algorithms and performance considerations."
+			"reasoning": "This task represents the most complex phase of the context implementation, requiring a sophisticated class design, optimization algorithms, and integration with multiple systems. The 5 existing subtasks cover the core implementation areas, but the complexity is high due to the need for intelligent context prioritization, token management, and performance monitoring."
-		},
-		{
-			"taskId": 32,
-			"taskTitle": "Implement \"learn\" Command for Automatic Cursor Rule Generation",
-			"complexityScore": 9,
-			"recommendedSubtasks": 10,
-			"expansionPrompt": "Expand the 'Implement \"learn\" Command for Automatic Cursor Rule Generation' task by detailing the specific steps for Cursor data analysis, rule management, and AI integration, including error handling and performance optimization.",
-			"reasoning": "Requires deep integration with Cursor's data, complex pattern analysis, and AI interaction. Significant error handling and performance optimization are needed."
 		},
 		{
 			"taskId": 40,
 			"taskTitle": "Implement 'plan' Command for Task Implementation Planning",
-			"complexityScore": 6,
+			"complexityScore": 5,
 			"recommendedSubtasks": 4,
-			"expansionPrompt": "Expand the 'Implement 'plan' Command for Task Implementation Planning' task by detailing the steps for retrieving task content, generating implementation plans with AI, and formatting the plan within XML tags.",
+			"expansionPrompt": "The current 4 subtasks for implementing the 'plan' command appear well-structured. Consider if any additional subtasks are needed for testing, documentation, or integration with existing task management workflows.",
-			"reasoning": "Involves AI integration and requires careful formatting and error handling. Switching between Claude and Perplexity adds complexity."
+			"reasoning": "This task involves creating a new command that leverages AI to generate implementation plans. The existing 4 subtasks cover the main implementation areas (retrieving task content, generating plans with AI, formatting in XML, and error handling). The complexity is moderate as it builds on existing patterns for task updates but requires careful AI integration."
 		},
 		{
 			"taskId": 41,
 			"taskTitle": "Implement Visual Task Dependency Graph in Terminal",
 			"complexityScore": 8,
-			"recommendedSubtasks": 8,
+			"recommendedSubtasks": 10,
-			"expansionPrompt": "Expand the 'Implement Visual Task Dependency Graph in Terminal' task by detailing the steps for designing the graph rendering system, implementing layout algorithms, and handling circular dependencies and filtering options.",
+			"expansionPrompt": "The current 10 subtasks for implementing the visual task dependency graph appear comprehensive. Consider if any additional subtasks are needed for performance optimization with large graphs or additional visualization options.",
-			"reasoning": "Requires complex graph algorithms and terminal rendering. Accessibility and performance are important considerations."
+			"reasoning": "This task involves creating a sophisticated visualization system for terminal display, which is inherently complex due to layout algorithms, ASCII/Unicode rendering, and handling complex dependency relationships. The 10 existing subtasks cover all major aspects of implementation, from CLI interface to accessibility features."
 		},
 		{
 			"taskId": 42,
 			"taskTitle": "Implement MCP-to-MCP Communication Protocol",
-			"complexityScore": 8,
+			"complexityScore": 9,
-			"recommendedSubtasks": 7,
+			"recommendedSubtasks": 8,
-			"expansionPrompt": "Expand the 'Implement MCP-to-MCP Communication Protocol' task by detailing the steps for defining the protocol, implementing the adapter pattern, and building the client module, including error handling and security considerations.",
+			"expansionPrompt": "The current 8 subtasks for implementing the MCP-to-MCP communication protocol appear well-structured. Consider if any additional subtasks are needed for security hardening, performance optimization, or comprehensive documentation.",
-			"reasoning": "Requires designing a new protocol and implementing communication with external systems. Security and error handling are critical."
+			"reasoning": "This task involves designing and implementing a complex communication protocol between different MCP tools and servers. It requires sophisticated adapter patterns, client-server architecture, and handling of multiple operational modes. The complexity is very high due to the need for standardization, security, and backward compatibility."
-		},
-		{
-			"taskId": 43,
-			"taskTitle": "Add Research Flag to Add-Task Command",
-			"complexityScore": 5,
-			"recommendedSubtasks": 3,
-			"expansionPrompt": "Expand the 'Add Research Flag to Add-Task Command' task by detailing the steps for updating the command parser, generating research subtasks, and linking them to the parent task.",
-			"reasoning": "Relatively straightforward, but requires careful handling of subtask generation and linking."
 		},
 		{
 			"taskId": 44,
 			"taskTitle": "Implement Task Automation with Webhooks and Event Triggers",
 			"complexityScore": 8,
 			"recommendedSubtasks": 7,
-			"expansionPrompt": "Expand the 'Implement Task Automation with Webhooks and Event Triggers' task by detailing the steps for implementing the webhook registration system, event system, and trigger definition interface, including security and error handling.",
+			"expansionPrompt": "The current 7 subtasks for implementing task automation with webhooks appear comprehensive. Consider if any additional subtasks are needed for security testing, rate limiting implementation, or webhook monitoring tools.",
-			"reasoning": "Requires designing a robust event system and integrating with external services. Security and error handling are critical."
+			"reasoning": "This task involves creating a sophisticated event system with webhooks for integration with external services. The complexity is high due to the need for secure authentication, reliable delivery mechanisms, and handling of various webhook formats and protocols. The existing subtasks cover the main implementation areas but security and monitoring could be emphasized more."
 		},
 		{
 			"taskId": 45,
 			"taskTitle": "Implement GitHub Issue Import Feature",
-			"complexityScore": 7,
+			"complexityScore": 6,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement GitHub Issue Import Feature' task by detailing the steps for parsing the URL, fetching issue details from the GitHub API, and generating a well-formatted task.",
+			"expansionPrompt": "The current 5 subtasks for implementing the GitHub issue import feature appear well-structured. Consider if any additional subtasks are needed for handling GitHub API rate limiting, caching, or supporting additional issue metadata.",
-			"reasoning": "Requires interacting with the GitHub API and handling various error conditions. Authentication adds complexity."
+			"reasoning": "This task involves integrating with the GitHub API to import issues as tasks. The complexity is moderate as it requires API authentication, data mapping, and error handling. The existing 5 subtasks cover the main implementation areas from design to end-to-end implementation."
 		},
 		{
 			"taskId": 46,
 			"taskTitle": "Implement ICE Analysis Command for Task Prioritization",
 			"complexityScore": 7,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement ICE Analysis Command for Task Prioritization' task by detailing the steps for calculating ICE scores, generating the report file, and implementing the CLI rendering.",
+			"expansionPrompt": "The current 5 subtasks for implementing the ICE analysis command appear comprehensive. Consider if any additional subtasks are needed for visualization of ICE scores or integration with other prioritization methods.",
-			"reasoning": "Requires AI integration for scoring and careful formatting of the report. Integration with existing complexity reports adds complexity."
+			"reasoning": "This task involves creating an AI-powered analysis system for task prioritization using the ICE methodology. The complexity is high due to the need for sophisticated scoring algorithms, AI integration, and report generation. The existing subtasks cover the main implementation areas from algorithm design to integration with existing systems."
 		},
 		{
 			"taskId": 47,
 			"taskTitle": "Enhance Task Suggestion Actions Card Workflow",
-			"complexityScore": 7,
+			"complexityScore": 6,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Expand the 'Enhance Task Suggestion Actions Card Workflow' task by detailing the steps for implementing the task expansion, context addition, and task management phases, including UI/UX considerations.",
+			"expansionPrompt": "The current 6 subtasks for enhancing the task suggestion actions card workflow appear well-structured. Consider if any additional subtasks are needed for user testing, accessibility improvements, or performance optimization.",
-			"reasoning": "Requires significant UI/UX work and careful state management. Integration with existing functionality is crucial."
+			"reasoning": "This task involves redesigning the UI workflow for task expansion and management. The complexity is moderate as it requires careful UX design and state management but builds on existing components. The 6 existing subtasks cover the main implementation areas from design to testing."
 		},
 		{
 			"taskId": 48,
 			"taskTitle": "Refactor Prompts into Centralized Structure",
-			"complexityScore": 5,
+			"complexityScore": 4,
 			"recommendedSubtasks": 3,
-			"expansionPrompt": "Expand the 'Refactor Prompts into Centralized Structure' task by detailing the steps for creating the 'prompts' directory, extracting prompts into individual files, and updating functions to import them.",
+			"expansionPrompt": "The current 3 subtasks for refactoring prompts into a centralized structure appear appropriate. Consider if any additional subtasks are needed for prompt versioning, documentation, or testing.",
-			"reasoning": "Primarily a refactoring task, but requires careful attention to detail to avoid breaking existing functionality."
+			"reasoning": "This task involves a straightforward refactoring to improve code organization. The complexity is relatively low as it primarily involves moving code rather than creating new functionality. The 3 existing subtasks cover the main implementation areas from directory structure to integration."
 		},
 		{
 			"taskId": 49,
 			"taskTitle": "Implement Code Quality Analysis Command",
 			"complexityScore": 8,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Expand the 'Implement Code Quality Analysis Command' task by detailing the steps for pattern recognition, best practice verification, and improvement recommendations, including AI integration and task creation.",
+			"expansionPrompt": "The current 6 subtasks for implementing the code quality analysis command appear comprehensive. Consider if any additional subtasks are needed for performance optimization with large codebases or integration with existing code quality tools.",
-			"reasoning": "Requires complex code analysis and AI integration. Generating actionable recommendations adds complexity."
+			"reasoning": "This task involves creating a sophisticated code analysis system with pattern recognition, best practice verification, and AI-powered recommendations. The complexity is high due to the need for code parsing, complex analysis algorithms, and integration with AI services. The existing subtasks cover the main implementation areas from algorithm design to user interface."
 		},
 		{
 			"taskId": 50,
 			"taskTitle": "Implement Test Coverage Tracking System by Task",
 			"complexityScore": 9,
-			"recommendedSubtasks": 7,
+			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement Test Coverage Tracking System by Task' task by detailing the steps for creating the tests.json file structure, developing the coverage report parser, and implementing the CLI commands and AI-powered test generation system.",
+			"expansionPrompt": "The current 5 subtasks for implementing the test coverage tracking system appear well-structured. Consider if any additional subtasks are needed for integration with CI/CD systems, performance optimization, or visualization tools.",
-			"reasoning": "A comprehensive system requiring deep integration with testing tools and AI. Maintaining bidirectional relationships adds complexity."
+			"reasoning": "This task involves creating a complex system that maps test coverage to specific tasks and subtasks. The complexity is very high due to the need for sophisticated data structures, integration with coverage tools, and AI-powered test generation. The existing subtasks are comprehensive and cover the main implementation areas from data structure design to AI integration."
 		},
 		{
 			"taskId": 51,
 			"taskTitle": "Implement Perplexity Research Command",
-			"complexityScore": 7,
+			"complexityScore": 6,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement Perplexity Research Command' task by detailing the steps for creating the Perplexity API client, implementing task context extraction, and building the CLI interface.",
+			"expansionPrompt": "The current 5 subtasks for implementing the Perplexity research command appear comprehensive. Consider if any additional subtasks are needed for caching optimization, result formatting, or integration with other research tools.",
-			"reasoning": "Requires API integration and careful formatting of the research results. Caching adds complexity."
+			"reasoning": "This task involves creating a new command that integrates with the Perplexity AI API for research. The complexity is moderate as it requires API integration, context extraction, and result formatting. The 5 existing subtasks cover the main implementation areas from API client to caching system."
 		},
 		{
 			"taskId": 52,
 			"taskTitle": "Implement Task Suggestion Command for CLI",
-			"complexityScore": 7,
+			"complexityScore": 6,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement Task Suggestion Command for CLI' task by detailing the steps for collecting existing task data, generating task suggestions with AI, and implementing the interactive CLI interface.",
+			"expansionPrompt": "The current 5 subtasks for implementing the task suggestion command appear well-structured. Consider if any additional subtasks are needed for suggestion quality evaluation, user feedback collection, or integration with existing task workflows.",
-			"reasoning": "Requires AI integration and careful design of the interactive interface. Handling various flag combinations adds complexity."
+			"reasoning": "This task involves creating a new CLI command that generates contextually relevant task suggestions using AI. The complexity is moderate as it requires AI integration, context collection, and interactive CLI interfaces. The existing subtasks cover the main implementation areas from data collection to user interface."
 		},
 		{
 			"taskId": 53,
 			"taskTitle": "Implement Subtask Suggestion Feature for Parent Tasks",
-			"complexityScore": 7,
+			"complexityScore": 6,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Expand the 'Implement Subtask Suggestion Feature for Parent Tasks' task by detailing the steps for validating parent tasks, gathering context, generating subtask suggestions with AI, and implementing the interactive CLI interface.",
+			"expansionPrompt": "The current 6 subtasks for implementing the subtask suggestion feature appear comprehensive. Consider if any additional subtasks are needed for suggestion quality metrics, user feedback collection, or performance optimization.",
-			"reasoning": "Requires AI integration and careful design of the interactive interface. Linking subtasks to parent tasks adds complexity."
+			"reasoning": "This task involves creating a feature that suggests contextually relevant subtasks for parent tasks. The complexity is moderate as it builds on existing task management systems but requires sophisticated AI integration and context analysis. The 6 existing subtasks cover the main implementation areas from validation to testing."
 		},
 		{
 			"taskId": 55,
 			"taskTitle": "Implement Positional Arguments Support for CLI Commands",
-			"complexityScore": 7,
+			"complexityScore": 5,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement Positional Arguments Support for CLI Commands' task by detailing the steps for updating the argument parsing logic, defining the positional argument order, and handling edge cases.",
+			"expansionPrompt": "The current 5 subtasks for implementing positional arguments support appear well-structured. Consider if any additional subtasks are needed for backward compatibility testing, documentation updates, or user experience improvements.",
-			"reasoning": "Requires careful modification of the command parsing logic and ensuring backward compatibility. Handling edge cases adds complexity."
+			"reasoning": "This task involves modifying the command parsing logic to support positional arguments alongside the existing flag-based syntax. The complexity is moderate as it requires careful handling of different argument styles and edge cases. The 5 existing subtasks cover the main implementation areas from analysis to documentation."
 		},
 		{
 			"taskId": 57,
 			"taskTitle": "Enhance Task-Master CLI User Experience and Interface",
 			"complexityScore": 7,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Expand the 'Enhance Task-Master CLI User Experience and Interface' task by detailing the steps for log management, visual enhancements, interactive elements, and output formatting.",
+			"expansionPrompt": "The current 6 subtasks for enhancing the CLI user experience appear comprehensive. Consider if any additional subtasks are needed for accessibility testing, internationalization, or performance optimization.",
-			"reasoning": "Requires significant UI/UX work and careful consideration of different terminal environments. Reducing verbose logging adds complexity."
+			"reasoning": "This task involves a significant overhaul of the CLI interface to improve user experience. The complexity is high due to the breadth of changes (logging, visual elements, interactive components, etc.) and the need for consistent design across all commands. The 6 existing subtasks cover the main implementation areas from log management to help systems."
 		},
 		{
 			"taskId": 60,
 			"taskTitle": "Implement Mentor System with Round-Table Discussion Feature",
 			"complexityScore": 8,
 			"recommendedSubtasks": 7,
-			"expansionPrompt": "Expand the 'Implement Mentor System with Round-Table Discussion Feature' task by detailing the steps for mentor management, round-table discussion implementation, and integration with the task system, including LLM integration.",
+			"expansionPrompt": "The current 7 subtasks for implementing the mentor system appear well-structured. Consider if any additional subtasks are needed for mentor personality consistency, discussion quality evaluation, or performance optimization with multiple mentors.",
-			"reasoning": "Requires complex AI simulation and careful formatting of the discussion output. Integrating with the task system adds complexity."
+			"reasoning": "This task involves creating a sophisticated mentor simulation system with round-table discussions. The complexity is high due to the need for personality simulation, complex LLM integration, and structured discussion management. The 7 existing subtasks cover the main implementation areas from architecture to testing."
-		},
-		{
-			"taskId": 61,
-			"taskTitle": "Implement Flexible AI Model Management",
-			"complexityScore": 9,
-			"recommendedSubtasks": 8,
-			"expansionPrompt": "Expand the 'Implement Flexible AI Model Management' task by detailing the steps for creating the configuration management module, implementing the CLI command parser, and integrating the Vercel AI SDK.",
-			"reasoning": "Requires deep integration with multiple AI models and careful management of API keys and configuration options. Vercel AI SDK integration adds complexity."
 		},
 		{
 			"taskId": 62,
 			"taskTitle": "Add --simple Flag to Update Commands for Direct Text Input",
-			"complexityScore": 5,
+			"complexityScore": 4,
-			"recommendedSubtasks": 4,
+			"recommendedSubtasks": 8,
-			"expansionPrompt": "Expand the 'Add --simple Flag to Update Commands for Direct Text Input' task by detailing the steps for updating the command parsers, implementing the conditional logic, and formatting the user input with a timestamp.",
+			"expansionPrompt": "The current 8 subtasks for implementing the --simple flag appear comprehensive. Consider if any additional subtasks are needed for user experience testing or documentation updates.",
-			"reasoning": "Relatively straightforward, but requires careful attention to formatting and ensuring consistency with AI-processed updates."
+			"reasoning": "This task involves adding a simple flag option to bypass AI processing for updates. The complexity is relatively low as it primarily involves modifying existing command handlers and adding a flag. The 8 existing subtasks are very detailed and cover all aspects of implementation from command parsing to testing."
 		},
 		{
 			"taskId": 63,
 			"taskTitle": "Add pnpm Support for the Taskmaster Package",
-			"complexityScore": 7,
+			"complexityScore": 5,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 8,
-			"expansionPrompt": "Expand the 'Add pnpm Support for the Taskmaster Package' task by detailing the steps for updating the documentation, ensuring package scripts compatibility, and testing the installation and operation with pnpm.",
+			"expansionPrompt": "The current 8 subtasks for adding pnpm support appear comprehensive. Consider if any additional subtasks are needed for CI/CD integration, performance comparison, or documentation updates.",
-			"reasoning": "Requires careful attention to detail to ensure compatibility with pnpm's execution model. Testing and documentation are crucial."
+			"reasoning": "This task involves ensuring the package works correctly with pnpm as an alternative package manager. The complexity is moderate as it requires careful testing of installation processes and scripts across different environments. The 8 existing subtasks cover all major aspects from documentation to binary verification."
 		},
 		{
 			"taskId": 64,
 			"taskTitle": "Add Yarn Support for Taskmaster Installation",
-			"complexityScore": 7,
+			"complexityScore": 5,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 9,
-			"expansionPrompt": "Expand the 'Add Yarn Support for Taskmaster Installation' task by detailing the steps for updating package.json, adding Yarn-specific configuration files, and testing the installation and operation with Yarn.",
+			"expansionPrompt": "The current 9 subtasks for adding Yarn support appear comprehensive. Consider if any additional subtasks are needed for performance testing, CI/CD integration, or compatibility with different Yarn versions.",
-			"reasoning": "Requires careful attention to detail to ensure compatibility with Yarn's execution model. Testing and documentation are crucial."
+			"reasoning": "This task involves ensuring the package works correctly with Yarn as an alternative package manager. The complexity is moderate as it requires careful testing of installation processes and scripts across different environments. The 9 existing subtasks are very detailed and cover all aspects from configuration to testing."
 		},
 		{
 			"taskId": 65,
 			"taskTitle": "Add Bun Support for Taskmaster Installation",
-			"complexityScore": 7,
+			"complexityScore": 6,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "Expand the 'Add Bun Support for Taskmaster Installation' task by detailing the steps for updating the installation scripts, testing the installation and operation with Bun, and updating the documentation.",
+			"expansionPrompt": "The current 6 subtasks for adding Bun support appear well-structured. Consider if any additional subtasks are needed for handling Bun-specific issues, performance testing, or documentation updates.",
-			"reasoning": "Requires careful attention to detail to ensure compatibility with Bun's execution model. Testing and documentation are crucial."
+			"reasoning": "This task involves adding support for the newer Bun package manager. The complexity is slightly higher than the other package manager tasks due to Bun's differences from Node.js and potential compatibility issues. The 6 existing subtasks cover the main implementation areas from research to documentation."
-		},
-		{
-			"taskId": 66,
-			"taskTitle": "Support Status Filtering in Show Command for Subtasks",
-			"complexityScore": 5,
-			"recommendedSubtasks": 4,
-			"expansionPrompt": "Expand the 'Support Status Filtering in Show Command for Subtasks' task by detailing the steps for updating the command parser, modifying the show command handler, and updating the help documentation.",
-			"reasoning": "Relatively straightforward, but requires careful handling of status validation and filtering."
 		},
 		{
 			"taskId": 67,
 			"taskTitle": "Add CLI JSON output and Cursor keybindings integration",
-			"complexityScore": 7,
+			"complexityScore": 5,
-			"recommendedSubtasks": 6,
+			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Add CLI JSON output and Cursor keybindings integration' task by detailing the steps for implementing the JSON output logic, creating the install-keybindings command structure, and handling keybinding file manipulation.",
+			"expansionPrompt": "The current 5 subtasks for implementing JSON output and Cursor keybindings appear well-structured. Consider if any additional subtasks are needed for testing across different operating systems, documentation updates, or user experience improvements.",
-			"reasoning": "Requires careful formatting of the JSON output and handling of file system operations. OS detection adds complexity."
+			"reasoning": "This task involves two distinct features: adding JSON output to CLI commands and creating a keybindings installation command. The complexity is moderate as it requires careful handling of different output formats and OS-specific file paths. The 5 existing subtasks cover the main implementation areas for both features."
 		},
 		{
 			"taskId": 68,
 			"taskTitle": "Ability to create tasks without parsing PRD",
 			"complexityScore": 3,
 			"recommendedSubtasks": 2,
-			"expansionPrompt": "Expand the 'Ability to create tasks without parsing PRD' task by detailing the steps for creating tasks without a PRD.",
+			"expansionPrompt": "The current 2 subtasks for implementing task creation without PRD appear appropriate. Consider if any additional subtasks are needed for validation, error handling, or integration with existing task management workflows.",
-			"reasoning": "Simple task to allow task creation without a PRD."
+			"reasoning": "This task involves a relatively simple modification to allow task creation without requiring a PRD document. The complexity is low as it primarily involves creating a form interface and saving functionality. The 2 existing subtasks cover the main implementation areas of UI design and data saving."
+		},
+		{
+			"taskId": 72,
+			"taskTitle": "Implement PDF Generation for Project Progress and Dependency Overview",
+			"complexityScore": 7,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "The current 6 subtasks for implementing PDF generation appear comprehensive. Consider if any additional subtasks are needed for handling large projects, additional visualization options, or integration with existing reporting tools.",
+			"reasoning": "This task involves creating a feature to generate PDF reports of project progress and dependency visualization. The complexity is high due to the need for PDF generation, data collection, and visualization integration. The 6 existing subtasks cover the main implementation areas from library selection to export options."
+		},
+		{
+			"taskId": 75,
+			"taskTitle": "Integrate Google Search Grounding for Research Role",
+			"complexityScore": 5,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "The current 4 subtasks for integrating Google Search Grounding appear well-structured. Consider if any additional subtasks are needed for testing with different query types, error handling, or performance optimization.",
+			"reasoning": "This task involves updating the AI service layer to enable Google Search Grounding for research roles. The complexity is moderate as it requires careful integration with the existing AI service architecture and conditional logic. The 4 existing subtasks cover the main implementation areas from service layer modification to testing."
+		},
+		{
+			"taskId": 76,
+			"taskTitle": "Develop E2E Test Framework for Taskmaster MCP Server (FastMCP over stdio)",
+			"complexityScore": 8,
+			"recommendedSubtasks": 7,
+			"expansionPrompt": "The current 7 subtasks for developing the E2E test framework appear comprehensive. Consider if any additional subtasks are needed for test result reporting, CI/CD integration, or performance benchmarking.",
+			"reasoning": "This task involves creating a sophisticated end-to-end testing framework for the MCP server. The complexity is high due to the need for subprocess management, protocol handling, and robust test case definition. The 7 existing subtasks cover the main implementation areas from architecture to documentation."
+		},
+		{
+			"taskId": 77,
+			"taskTitle": "Implement AI Usage Telemetry for Taskmaster (with external analytics endpoint)",
+			"complexityScore": 7,
+			"recommendedSubtasks": 18,
+			"expansionPrompt": "The current 18 subtasks for implementing AI usage telemetry appear very comprehensive. Consider if any additional subtasks are needed for security hardening, privacy compliance, or user feedback collection.",
+			"reasoning": "This task involves creating a telemetry system to track AI usage metrics. The complexity is high due to the need for secure data transmission, comprehensive data collection, and integration across multiple commands. The 18 existing subtasks are extremely detailed and cover all aspects of implementation from core utility to provider-specific updates."
+		},
+		{
+			"taskId": 80,
+			"taskTitle": "Implement Unique User ID Generation and Storage During Installation",
+			"complexityScore": 4,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "The current 5 subtasks for implementing unique user ID generation appear well-structured. Consider if any additional subtasks are needed for privacy compliance, security auditing, or integration with the telemetry system.",
+			"reasoning": "This task involves generating and storing a unique user identifier during installation. The complexity is relatively low as it primarily involves UUID generation and configuration file management. The 5 existing subtasks cover the main implementation areas from script structure to documentation."
+		},
+		{
+			"taskId": 81,
+			"taskTitle": "Task #81: Implement Comprehensive Local Telemetry System with Future Server Integration Capability",
+			"complexityScore": 8,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "The current 6 subtasks for implementing the comprehensive local telemetry system appear well-structured. Consider if any additional subtasks are needed for data migration, storage optimization, or visualization tools.",
+			"reasoning": "This task involves expanding the telemetry system to capture additional metrics and implement local storage with future server integration capability. The complexity is high due to the breadth of data collection, storage requirements, and privacy considerations. The 6 existing subtasks cover the main implementation areas from data collection to user-facing benefits."
+		},
+		{
+			"taskId": 82,
+			"taskTitle": "Update supported-models.json with token limit fields",
+			"complexityScore": 3,
+			"recommendedSubtasks": 1,
+			"expansionPrompt": "This task appears straightforward enough to be implemented without further subtasks. Focus on researching accurate token limit values for each model and ensuring backward compatibility.",
+			"reasoning": "This task involves a simple update to the supported-models.json file to include new token limit fields. The complexity is low as it primarily involves research and data entry. No subtasks are necessary as the task is well-defined and focused."
+		},
+		{
+			"taskId": 83,
+			"taskTitle": "Update config-manager.js defaults and getters",
+			"complexityScore": 4,
+			"recommendedSubtasks": 1,
+			"expansionPrompt": "This task appears straightforward enough to be implemented without further subtasks. Focus on updating the DEFAULTS object and related getter functions while maintaining backward compatibility.",
+			"reasoning": "This task involves updating the config-manager.js module to replace maxTokens with more specific token limit fields. The complexity is relatively low as it primarily involves modifying existing code rather than creating new functionality. No subtasks are necessary as the task is well-defined and focused."
+		},
+		{
+			"taskId": 84,
+			"taskTitle": "Implement token counting utility",
+			"complexityScore": 5,
+			"recommendedSubtasks": 1,
+			"expansionPrompt": "This task appears well-defined enough to be implemented without further subtasks. Focus on implementing accurate token counting for different models and proper fallback mechanisms.",
+			"reasoning": "This task involves creating a utility function to count tokens for different AI models. The complexity is moderate as it requires integration with the tiktoken library and handling different tokenization schemes. No subtasks are necessary as the task is well-defined and focused."
 		},
 		{
 			"taskId": 69,
 			"taskTitle": "Enhance Analyze Complexity for Specific Task IDs",
-			"complexityScore": 6,
+			"complexityScore": 7,
-			"recommendedSubtasks": 4,
+			"recommendedSubtasks": 6,
-			"expansionPrompt": "Expand the 'Enhance Analyze Complexity for Specific Task IDs' task by detailing the steps for modifying the core logic, updating the CLI, and updating the MCP tool.",
+			"expansionPrompt": "Break down the task 'Enhance Analyze Complexity for Specific Task IDs' into 6 subtasks focusing on: 1) Core logic modification to accept ID parameters, 2) Report merging functionality, 3) CLI interface updates, 4) MCP tool integration, 5) Documentation updates, and 6) Comprehensive testing across all components.",
-			"reasoning": "Requires modifying existing functionality and ensuring compatibility with both CLI and MCP."
+			"reasoning": "This task involves modifying existing functionality across multiple components (core logic, CLI, MCP) with complex logic for filtering tasks and merging reports. The implementation requires careful handling of different parameter combinations and edge cases. The task has interdependent components that need to work together seamlessly, and the report merging functionality adds significant complexity."
 		},
 		{
 			"taskId": 70,
 			"taskTitle": "Implement 'diagram' command for Mermaid diagram generation",
 			"complexityScore": 6,
-			"recommendedSubtasks": 4,
+			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement 'diagram' command for Mermaid diagram generation' task by detailing the steps for creating the command, generating the Mermaid diagram, and handling different output options.",
+			"expansionPrompt": "Break down the 'diagram' command implementation into 5 subtasks: 1) Command interface and parameter handling, 2) Task data extraction and transformation to Mermaid syntax, 3) Diagram rendering with status color coding, 4) Output formatting and file export functionality, and 5) Error handling and edge case management.",
-			"reasoning": "Requires generating Mermaid diagrams and handling different output options."
+			"reasoning": "This task requires implementing a new feature rather than modifying existing code, which reduces complexity from integration challenges. However, it involves working with visualization logic, dependency mapping, and multiple output formats. The color coding based on status and handling of dependency relationships adds moderate complexity. The task is well-defined but requires careful attention to diagram formatting and error handling."
 		},
 		{
-			"taskId": 72,
+			"taskId": 85,
-			"taskTitle": "Implement PDF Generation for Project Progress and Dependency Overview",
+			"taskTitle": "Update ai-services-unified.js for dynamic token limits",
-			"complexityScore": 8,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "Expand the 'Implement PDF Generation for Project Progress and Dependency Overview' task by detailing the steps for summarizing project progress, visualizing the dependency chain, and generating the PDF document.",
-			"reasoning": "Requires integrating with the diagram command and using a PDF generation library. Handling large dependency chains adds complexity."
-		},
-		{
-			"taskId": 73,
-			"taskTitle": "Implement Custom Model ID Support for Ollama/OpenRouter",
 			"complexityScore": 7,
 			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand the 'Implement Custom Model ID Support for Ollama/OpenRouter' task by detailing the steps for modifying the CLI, implementing the interactive setup, and handling validation and warnings.",
+			"expansionPrompt": "Break down the update of ai-services-unified.js for dynamic token limits into subtasks such as: (1) Import and integrate the token counting utility, (2) Refactor _unifiedServiceRunner to calculate and enforce dynamic token limits, (3) Update error handling for token limit violations, (4) Add and verify logging for token usage, (5) Write and execute tests for various prompt and model scenarios.",
-			"reasoning": "Requires integrating with external APIs and handling different model types. Validation and warnings are crucial."
+			"reasoning": "This task involves significant code changes to a core function, integration of a new utility, dynamic logic for multiple models, and robust error handling. It also requires comprehensive testing for edge cases and integration, making it moderately complex and best managed by splitting into focused subtasks."
 		},
 		{
-			"taskId": 75,
+			"taskId": 86,
-			"taskTitle": "Integrate Google Search Grounding for Research Role",
+			"taskTitle": "Update .taskmasterconfig schema and user guide",
 			"complexityScore": 6,
 			"recommendedSubtasks": 4,
-			"expansionPrompt": "Expand the 'Integrate Google Search Grounding for Research Role' task by detailing the steps for modifying the AI service layer, implementing the conditional logic, and updating the supported models.",
+			"expansionPrompt": "Expand this task into subtasks: (1) Draft a migration guide for users, (2) Update user documentation to explain new config fields, (3) Modify schema validation logic in config-manager.js, (4) Test and validate backward compatibility and error messaging.",
-			"reasoning": "Requires conditional logic and integration with the Google Search Grounding API."
+			"reasoning": "The task spans documentation, schema changes, migration guidance, and validation logic. While not algorithmically complex, it requires careful coordination and thorough testing to ensure a smooth user transition and robust validation."
 		},
 		{
-			"taskId": 76,
+			"taskId": 87,
-			"taskTitle": "Develop E2E Test Framework for Taskmaster MCP Server (FastMCP over stdio)",
+			"taskTitle": "Implement validation and error handling",
-			"complexityScore": 9,
+			"complexityScore": 5,
-			"recommendedSubtasks": 7,
+			"recommendedSubtasks": 4,
-			"expansionPrompt": "Expand the 'Develop E2E Test Framework for Taskmaster MCP Server (FastMCP over stdio)' task by detailing the steps for launching the FastMCP server, implementing the message protocol handler, and developing the request/response correlation mechanism.",
+			"expansionPrompt": "Decompose this task into: (1) Add validation logic for model and config loading, (2) Implement error handling and fallback mechanisms, (3) Enhance logging and reporting for token usage, (4) Develop helper functions for configuration suggestions and improvements.",
-			"reasoning": "Requires complex system integration and robust error handling. Designing a comprehensive test framework adds complexity."
+			"reasoning": "This task is primarily about adding validation, error handling, and logging. While important for robustness, the logic is straightforward and can be modularized into a few clear subtasks."
+		},
+		{
+			"taskId": 89,
+			"taskTitle": "Introduce Prioritize Command with Enhanced Priority Levels",
+			"complexityScore": 6,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Expand this task into: (1) Implement the prioritize command with all required flags and shorthands, (2) Update CLI output and help documentation for new priority levels, (3) Ensure backward compatibility with existing commands, (4) Add error handling for invalid inputs, (5) Write and run tests for all command scenarios.",
+			"reasoning": "This CLI feature requires command parsing, updating internal logic for new priority levels, documentation, and robust error handling. The complexity is moderate due to the need for backward compatibility and comprehensive testing."
+		},
+		{
+			"taskId": 90,
+			"taskTitle": "Implement Subtask Progress Analyzer and Reporting System",
+			"complexityScore": 8,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "Break down the analyzer implementation into: (1) Design and implement progress tracking logic, (2) Develop status validation and issue detection, (3) Build the reporting system with multiple output formats, (4) Integrate analyzer with the existing task management system, (5) Optimize for performance and scalability, (6) Write unit, integration, and performance tests.",
+			"reasoning": "This is a complex, multi-faceted feature involving data analysis, reporting, integration, and performance optimization. It touches many parts of the system and requires careful design, making it one of the most complex tasks in the list."
+		},
+		{
+			"taskId": 91,
+			"taskTitle": "Implement Move Command for Tasks and Subtasks",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Expand this task into: (1) Implement move logic for tasks and subtasks, (2) Handle edge cases (invalid ids, non-existent parents, circular dependencies), (3) Update CLI to support move command with flags, (4) Ensure data integrity and update relationships, (5) Write and execute tests for various move scenarios.",
+			"reasoning": "Moving tasks and subtasks requires careful handling of hierarchical data, edge cases, and data integrity. The command must be robust and user-friendly, necessitating multiple focused subtasks for safe implementation."
 		}
 	]
 }

src/ai-providers/anthropic.js

@@ -4,9 +4,9 @@
  * Implementation for interacting with Anthropic models (e.g., Claude)
  * using the Vercel AI SDK.
  */
+
 import { createAnthropic } from '@ai-sdk/anthropic';
-import { generateText, streamText, generateObject } from 'ai';
+import { BaseAIProvider } from './base-provider.js';
-import { log } from '../../scripts/modules/utils.js'; // Assuming utils is accessible
 
 // TODO: Implement standardized functions for generateText, streamText, generateObject
 
@@ -17,193 +17,38 @@ import { log } from '../../scripts/modules/utils.js'; // Assuming utils is acces
 // Remove the global variable and caching logic
 // let anthropicClient;
 
-function getClient(apiKey, baseUrl) {
+export class AnthropicAIProvider extends BaseAIProvider {
-	if (!apiKey) {
+	constructor() {
-		// In a real scenario, this would use the config resolver.
+		super();
-		// Throwing error here if key isn't passed for simplicity.
+		this.name = 'Anthropic';
-		// Keep the error check for the passed key
-		throw new Error('Anthropic API key is required.');
 	}
-	// Remove the check for anthropicClient
+
-	// if (!anthropicClient) {
+	/**
-	// TODO: Explore passing options like default headers if needed
+	 * Creates and returns an Anthropic client instance.
-	// Create and return a new instance directly with standard version header
+	 * @param {object} params - Parameters for client initialization
-	return createAnthropic({
+	 * @param {string} params.apiKey - Anthropic API key
-		apiKey: apiKey,
+	 * @param {string} [params.baseURL] - Optional custom API endpoint
-		...(baseUrl && { baseURL: baseUrl }),
+	 * @returns {Function} Anthropic client function
-		// Use standard version header instead of beta
+	 * @throws {Error} If API key is missing or initialization fails
-		headers: {
+	 */
-			'anthropic-beta': 'output-128k-2025-02-19'
+	getClient(params) {
+		try {
+			const { apiKey, baseURL } = params;
+
+			if (!apiKey) {
+				throw new Error('Anthropic API key is required.');
+			}
+
+			return createAnthropic({
+				apiKey,
+				...(baseURL && { baseURL }),
+				headers: {
+					'anthropic-beta': 'output-128k-2025-02-19'
+				}
+			});
+		} catch (error) {
+			this.handleError('client initialization', error);
 		}
-	});
-}
-
-// --- Standardized Service Function Implementations ---
-
-/**
- * Generates text using an Anthropic model.
- *
- * @param {object} params - Parameters for the text generation.
- * @param {string} params.apiKey - The Anthropic API key.
- * @param {string} params.modelId - The specific Anthropic model ID.
- * @param {Array<object>} params.messages - The messages array (e.g., [{ role: 'user', content: '...' }]).
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
- * @param {number} [params.temperature] - Temperature for generation.
- * @param {string} [params.baseUrl] - The base URL for the Anthropic API.
- * @returns {Promise<string>} The generated text content.
- * @throws {Error} If the API call fails.
- */
-export async function generateAnthropicText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl
-}) {
-	log('debug', `Generating Anthropic text with model: ${modelId}`);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		const result = await generateText({
-			model: client(modelId),
-			messages: messages,
-			maxTokens: maxTokens,
-			temperature: temperature
-			// Beta header moved to client initialization
-			// TODO: Add other relevant parameters like topP, topK if needed
-		});
-		log(
-			'debug',
-			`Anthropic generateText result received. Tokens: ${result.usage.completionTokens}/${result.usage.promptTokens}`
-		);
-		return result.text;
-	} catch (error) {
-		log('error', `Anthropic generateText failed: ${error.message}`);
-		// Consider more specific error handling or re-throwing a standardized error
-		throw error;
-	}
-}
-
-/**
- * Streams text using an Anthropic model.
- *
- * @param {object} params - Parameters for the text streaming.
- * @param {string} params.apiKey - The Anthropic API key.
- * @param {string} params.modelId - The specific Anthropic model ID.
- * @param {Array<object>} params.messages - The messages array.
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
- * @param {number} [params.temperature] - Temperature for generation.
- * @param {string} [params.baseUrl] - The base URL for the Anthropic API.
- * @returns {Promise<object>} The full stream result object from the Vercel AI SDK.
- * @throws {Error} If the API call fails to initiate the stream.
- */
-export async function streamAnthropicText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl
-}) {
-	log('debug', `Streaming Anthropic text with model: ${modelId}`);
-	try {
-		const client = getClient(apiKey, baseUrl);
-
-		log(
-			'debug',
-			'[streamAnthropicText] Parameters received by streamText:',
-			JSON.stringify(
-				{
-					modelId: modelId,
-					messages: messages,
-					maxTokens: maxTokens,
-					temperature: temperature
-				},
-				null,
-				2
-			)
-		);
-
-		const stream = await streamText({
-			model: client(modelId),
-			messages: messages,
-			maxTokens: maxTokens,
-			temperature: temperature
-			// TODO: Add other relevant parameters
-		});
-
-		// *** RETURN THE FULL STREAM OBJECT, NOT JUST stream.textStream ***
-		return stream;
-	} catch (error) {
-		log('error', `Anthropic streamText failed: ${error.message}`, error.stack);
-		throw error;
-	}
-}
-
-/**
- * Generates a structured object using an Anthropic model.
- * NOTE: Anthropic's tool/function calling support might have limitations
- * compared to OpenAI, especially regarding complex schemas or enforcement.
- * The Vercel AI SDK attempts to abstract this.
- *
- * @param {object} params - Parameters for object generation.
- * @param {string} params.apiKey - The Anthropic API key.
- * @param {string} params.modelId - The specific Anthropic model ID.
- * @param {Array<object>} params.messages - The messages array.
- * @param {import('zod').ZodSchema} params.schema - The Zod schema for the object.
- * @param {string} params.objectName - A name for the object/tool.
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
- * @param {number} [params.temperature] - Temperature for generation.
- * @param {number} [params.maxRetries] - Max retries for validation/generation.
- * @param {string} [params.baseUrl] - The base URL for the Anthropic API.
- * @returns {Promise<object>} The generated object matching the schema.
- * @throws {Error} If generation or validation fails.
- */
-export async function generateAnthropicObject({
-	apiKey,
-	modelId,
-	messages,
-	schema,
-	objectName = 'generated_object',
-	maxTokens,
-	temperature,
-	maxRetries = 3,
-	baseUrl
-}) {
-	log(
-		'debug',
-		`Generating Anthropic object ('${objectName}') with model: ${modelId}`
-	);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		log(
-			'debug',
-			`Using maxTokens: ${maxTokens}, temperature: ${temperature}, model: ${modelId}`
-		);
-		const result = await generateObject({
-			model: client(modelId),
-			mode: 'tool',
-			schema: schema,
-			messages: messages,
-			tool: {
-				name: objectName,
-				description: `Generate a ${objectName} based on the prompt.`
-			},
-			maxTokens: maxTokens,
-			temperature: temperature,
-			maxRetries: maxRetries
-		});
-		log(
-			'debug',
-			`Anthropic generateObject result received. Tokens: ${result.usage.completionTokens}/${result.usage.promptTokens}`
-		);
-		return result.object;
-	} catch (error) {
-		log(
-			'error',
-			`Anthropic generateObject ('${objectName}') failed: ${error.message}`
-		);
-		throw error;
 	}
 }
 

src/ai-providers/azure.js

@@ -0,0 +1,52 @@
+/**
+ * azure.js
+ * AI provider implementation for Azure OpenAI models using Vercel AI SDK.
+ */
+
+import { createAzure } from '@ai-sdk/azure';
+import { BaseAIProvider } from './base-provider.js';
+
+export class AzureProvider extends BaseAIProvider {
+	constructor() {
+		super();
+		this.name = 'Azure OpenAI';
+	}
+
+	/**
+	 * Validates Azure-specific authentication parameters
+	 * @param {object} params - Parameters to validate
+	 * @throws {Error} If required parameters are missing
+	 */
+	validateAuth(params) {
+		if (!params.apiKey) {
+			throw new Error('Azure API key is required');
+		}
+
+		if (!params.baseURL) {
+			throw new Error(
+				'Azure endpoint URL is required. Set it in .taskmasterconfig global.azureBaseURL or models.[role].baseURL'
+			);
+		}
+	}
+
+	/**
+	 * Creates and returns an Azure OpenAI client instance.
+	 * @param {object} params - Parameters for client initialization
+	 * @param {string} params.apiKey - Azure OpenAI API key
+	 * @param {string} params.baseURL - Azure OpenAI endpoint URL (from .taskmasterconfig global.azureBaseURL or models.[role].baseURL)
+	 * @returns {Function} Azure OpenAI client function
+	 * @throws {Error} If required parameters are missing or initialization fails
+	 */
+	getClient(params) {
+		try {
+			const { apiKey, baseURL } = params;
+
+			return createAzure({
+				apiKey,
+				baseURL
+			});
+		} catch (error) {
+			this.handleError('client initialization', error);
+		}
+	}
+}

src/ai-providers/base-provider.js

@@ -0,0 +1,214 @@
+import { generateText, streamText, generateObject } from 'ai';
+import { log } from '../../scripts/modules/index.js';
+
+/**
+ * Base class for all AI providers
+ */
+export class BaseAIProvider {
+	constructor() {
+		if (this.constructor === BaseAIProvider) {
+			throw new Error('BaseAIProvider cannot be instantiated directly');
+		}
+
+		// Each provider must set their name
+		this.name = this.constructor.name;
+	}
+
+	/**
+	 * Validates authentication parameters - can be overridden by providers
+	 * @param {object} params - Parameters to validate
+	 */
+	validateAuth(params) {
+		// Default: require API key (most providers need this)
+		if (!params.apiKey) {
+			throw new Error(`${this.name} API key is required`);
+		}
+	}
+
+	/**
+	 * Validates common parameters across all methods
+	 * @param {object} params - Parameters to validate
+	 */
+	validateParams(params) {
+		// Validate authentication (can be overridden by providers)
+		this.validateAuth(params);
+
+		// Validate required model ID
+		if (!params.modelId) {
+			throw new Error(`${this.name} Model ID is required`);
+		}
+
+		// Validate optional parameters
+		this.validateOptionalParams(params);
+	}
+
+	/**
+	 * Validates optional parameters like temperature and maxTokens
+	 * @param {object} params - Parameters to validate
+	 */
+	validateOptionalParams(params) {
+		if (
+			params.temperature !== undefined &&
+			(params.temperature < 0 || params.temperature > 1)
+		) {
+			throw new Error('Temperature must be between 0 and 1');
+		}
+		if (params.maxTokens !== undefined && params.maxTokens <= 0) {
+			throw new Error('maxTokens must be greater than 0');
+		}
+	}
+
+	/**
+	 * Validates message array structure
+	 */
+	validateMessages(messages) {
+		if (!messages || !Array.isArray(messages) || messages.length === 0) {
+			throw new Error('Invalid or empty messages array provided');
+		}
+
+		for (const msg of messages) {
+			if (!msg.role || !msg.content) {
+				throw new Error(
+					'Invalid message format. Each message must have role and content'
+				);
+			}
+		}
+	}
+
+	/**
+	 * Common error handler
+	 */
+	handleError(operation, error) {
+		const errorMessage = error.message || 'Unknown error occurred';
+		log('error', `${this.name} ${operation} failed: ${errorMessage}`, {
+			error
+		});
+		throw new Error(
+			`${this.name} API error during ${operation}: ${errorMessage}`
+		);
+	}
+
+	/**
+	 * Creates and returns a client instance for the provider
+	 * @abstract
+	 */
+	getClient(params) {
+		throw new Error('getClient must be implemented by provider');
+	}
+
+	/**
+	 * Generates text using the provider's model
+	 */
+	async generateText(params) {
+		try {
+			this.validateParams(params);
+			this.validateMessages(params.messages);
+
+			log(
+				'debug',
+				`Generating ${this.name} text with model: ${params.modelId}`
+			);
+
+			const client = this.getClient(params);
+			const result = await generateText({
+				model: client(params.modelId),
+				messages: params.messages,
+				maxTokens: params.maxTokens,
+				temperature: params.temperature
+			});
+
+			log(
+				'debug',
+				`${this.name} generateText completed successfully for model: ${params.modelId}`
+			);
+
+			return {
+				text: result.text,
+				usage: {
+					inputTokens: result.usage?.promptTokens,
+					outputTokens: result.usage?.completionTokens,
+					totalTokens: result.usage?.totalTokens
+				}
+			};
+		} catch (error) {
+			this.handleError('text generation', error);
+		}
+	}
+
+	/**
+	 * Streams text using the provider's model
+	 */
+	async streamText(params) {
+		try {
+			this.validateParams(params);
+			this.validateMessages(params.messages);
+
+			log('debug', `Streaming ${this.name} text with model: ${params.modelId}`);
+
+			const client = this.getClient(params);
+			const stream = await streamText({
+				model: client(params.modelId),
+				messages: params.messages,
+				maxTokens: params.maxTokens,
+				temperature: params.temperature
+			});
+
+			log(
+				'debug',
+				`${this.name} streamText initiated successfully for model: ${params.modelId}`
+			);
+
+			return stream;
+		} catch (error) {
+			this.handleError('text streaming', error);
+		}
+	}
+
+	/**
+	 * Generates a structured object using the provider's model
+	 */
+	async generateObject(params) {
+		try {
+			this.validateParams(params);
+			this.validateMessages(params.messages);
+
+			if (!params.schema) {
+				throw new Error('Schema is required for object generation');
+			}
+			if (!params.objectName) {
+				throw new Error('Object name is required for object generation');
+			}
+
+			log(
+				'debug',
+				`Generating ${this.name} object ('${params.objectName}') with model: ${params.modelId}`
+			);
+
+			const client = this.getClient(params);
+			const result = await generateObject({
+				model: client(params.modelId),
+				messages: params.messages,
+				schema: params.schema,
+				mode: 'tool',
+				maxTokens: params.maxTokens,
+				temperature: params.temperature
+			});
+
+			log(
+				'debug',
+				`${this.name} generateObject completed successfully for model: ${params.modelId}`
+			);
+
+			return {
+				object: result.object,
+				usage: {
+					inputTokens: result.usage?.promptTokens,
+					outputTokens: result.usage?.completionTokens,
+					totalTokens: result.usage?.totalTokens
+				}
+			};
+		} catch (error) {
+			this.handleError('object generation', error);
+		}
+	}
+}

src/ai-providers/bedrock.js

@@ -0,0 +1,41 @@
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+import { BaseAIProvider } from './base-provider.js';
+
+export class BedrockAIProvider extends BaseAIProvider {
+	constructor() {
+		super();
+		this.name = 'Bedrock';
+	}
+
+	/**
+	 * Override auth validation - Bedrock uses AWS credentials instead of API keys
+	 * @param {object} params - Parameters to validate
+	 */
+	validateAuth(params) {}
+
+	/**
+	 * Creates and returns a Bedrock client instance.
+	 * See https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html
+	 * for AWS SDK environment variables and configuration options.
+	 */
+	getClient(params) {
+		try {
+			const {
+				profile = process.env.AWS_PROFILE || 'default',
+				region = process.env.AWS_DEFAULT_REGION || 'us-east-1',
+				baseURL
+			} = params;
+
+			const credentialProvider = fromNodeProviderChain({ profile });
+
+			return createAmazonBedrock({
+				region,
+				credentialProvider,
+				...(baseURL && { baseURL })
+			});
+		} catch (error) {
+			this.handleError('client initialization', error);
+		}
+	}
+}

src/ai-providers/google-vertex.js

@@ -0,0 +1,150 @@
+/**
+ * google-vertex.js
+ * AI provider implementation for Google Vertex AI models using Vercel AI SDK.
+ */
+
+import { createVertex } from '@ai-sdk/google-vertex';
+import { BaseAIProvider } from './base-provider.js';
+import { resolveEnvVariable } from '../../scripts/modules/utils.js';
+import { log } from '../../scripts/modules/utils.js';
+
+// Vertex-specific error classes
+class VertexAuthError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = 'VertexAuthError';
+		this.code = 'vertex_auth_error';
+	}
+}
+
+class VertexConfigError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = 'VertexConfigError';
+		this.code = 'vertex_config_error';
+	}
+}
+
+class VertexApiError extends Error {
+	constructor(message, statusCode) {
+		super(message);
+		this.name = 'VertexApiError';
+		this.code = 'vertex_api_error';
+		this.statusCode = statusCode;
+	}
+}
+
+export class VertexAIProvider extends BaseAIProvider {
+	constructor() {
+		super();
+		this.name = 'Google Vertex AI';
+	}
+
+	/**
+	 * Validates Vertex AI-specific authentication parameters
+	 * @param {object} params - Parameters to validate
+	 * @throws {Error} If required parameters are missing
+	 */
+	validateAuth(params) {
+		const { apiKey, projectId, location, credentials } = params;
+
+		// Check for API key OR service account credentials
+		if (!apiKey && !credentials) {
+			throw new VertexAuthError(
+				'Either Google API key (GOOGLE_API_KEY) or service account credentials (GOOGLE_APPLICATION_CREDENTIALS) is required for Vertex AI'
+			);
+		}
+
+		// Project ID is required for Vertex AI
+		if (!projectId) {
+			throw new VertexConfigError(
+				'Google Cloud project ID is required for Vertex AI. Set VERTEX_PROJECT_ID environment variable.'
+			);
+		}
+
+		// Location is required for Vertex AI
+		if (!location) {
+			throw new VertexConfigError(
+				'Google Cloud location is required for Vertex AI. Set VERTEX_LOCATION environment variable (e.g., "us-central1").'
+			);
+		}
+	}
+
+	/**
+	 * Creates and returns a Google Vertex AI client instance.
+	 * @param {object} params - Parameters for client initialization
+	 * @param {string} [params.apiKey] - Google API key
+	 * @param {string} params.projectId - Google Cloud project ID
+	 * @param {string} params.location - Google Cloud location (e.g., "us-central1")
+	 * @param {object} [params.credentials] - Service account credentials object
+	 * @param {string} [params.baseURL] - Optional custom API endpoint
+	 * @returns {Function} Google Vertex AI client function
+	 * @throws {Error} If required parameters are missing or initialization fails
+	 */
+	getClient(params) {
+		try {
+			// Validate required parameters
+			this.validateAuth(params);
+
+			const { apiKey, projectId, location, credentials, baseURL } = params;
+
+			// Configure auth options - either API key or service account
+			const authOptions = {};
+			if (apiKey) {
+				authOptions.apiKey = apiKey;
+			} else if (credentials) {
+				authOptions.googleAuthOptions = credentials;
+			}
+
+			// Return Vertex AI client
+			return createVertex({
+				...authOptions,
+				projectId,
+				location,
+				...(baseURL && { baseURL })
+			});
+		} catch (error) {
+			this.handleError('client initialization', error);
+		}
+	}
+
+	/**
+	 * Handle errors from Vertex AI
+	 * @param {string} operation - Description of the operation that failed
+	 * @param {Error} error - The error object
+	 * @throws {Error} Rethrows the error with additional context
+	 */
+	handleError(operation, error) {
+		log('error', `Vertex AI ${operation} error:`, error);
+
+		// Handle known error types
+		if (
+			error.name === 'VertexAuthError' ||
+			error.name === 'VertexConfigError' ||
+			error.name === 'VertexApiError'
+		) {
+			throw error;
+		}
+
+		// Handle network/API errors
+		if (error.response) {
+			const statusCode = error.response.status;
+			const errorMessage = error.response.data?.error?.message || error.message;
+
+			// Categorize by status code
+			if (statusCode === 401 || statusCode === 403) {
+				throw new VertexAuthError(`Authentication failed: ${errorMessage}`);
+			} else if (statusCode === 400) {
+				throw new VertexConfigError(`Invalid request: ${errorMessage}`);
+			} else {
+				throw new VertexApiError(
+					`API error (${statusCode}): ${errorMessage}`,
+					statusCode
+				);
+			}
+		}
+
+		// Generic error handling
+		throw new Error(`Vertex AI ${operation} failed: ${error.message}`);
+	}
+}

src/ai-providers/google.js

@@ -1,162 +1,39 @@
 /**
  * google.js
- * AI provider implementation for Google AI models (e.g., Gemini) using Vercel AI SDK.
+ * AI provider implementation for Google AI models using Vercel AI SDK.
  */
 
-// import { GoogleGenerativeAI } from '@ai-sdk/google'; // Incorrect import
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
-import { createGoogleGenerativeAI } from '@ai-sdk/google'; // Correct import for customization
+import { BaseAIProvider } from './base-provider.js';
-import { generateText, streamText, generateObject } from 'ai'; // Import from main 'ai' package
-import { log } from '../../scripts/modules/utils.js'; // Import logging utility
 
-// Consider making model configurable via config-manager.js later
+export class GoogleAIProvider extends BaseAIProvider {
-const DEFAULT_MODEL = 'gemini-2.0-pro'; // Or a suitable default
+	constructor() {
-const DEFAULT_TEMPERATURE = 0.2; // Or a suitable default
+		super();
-
+		this.name = 'Google';
-function getClient(apiKey, baseUrl) {
-	if (!apiKey) {
-		throw new Error('Google API key is required.');
 	}
-	return createGoogleGenerativeAI({
-		apiKey: apiKey,
-		...(baseUrl && { baseURL: baseUrl })
-	});
-}
 
-/**
+	/**
- * Generates text using a Google AI model.
+	 * Creates and returns a Google AI client instance.
- *
+	 * @param {object} params - Parameters for client initialization
- * @param {object} params - Parameters for the generation.
+	 * @param {string} params.apiKey - Google API key
- * @param {string} params.apiKey - Google API Key.
+	 * @param {string} [params.baseURL] - Optional custom API endpoint
- * @param {string} params.modelId - Specific model ID to use (overrides default).
+	 * @returns {Function} Google AI client function
- * @param {number} params.temperature - Generation temperature.
+	 * @throws {Error} If API key is missing or initialization fails
- * @param {Array<object>} params.messages - The conversation history (system/user prompts).
+	 */
- * @param {number} [params.maxTokens] - Optional max tokens.
+	getClient(params) {
- * @returns {Promise<string>} The generated text content.
+		try {
- * @throws {Error} If API key is missing or API call fails.
+			const { apiKey, baseURL } = params;
- */
-async function generateGoogleText({
-	apiKey,
-	modelId = DEFAULT_MODEL,
-	temperature = DEFAULT_TEMPERATURE,
-	messages,
-	maxTokens,
-	baseUrl
-}) {
-	if (!apiKey) {
-		throw new Error('Google API key is required.');
-	}
-	log('info', `Generating text with Google model: ${modelId}`);
 
-	try {
+			if (!apiKey) {
-		const googleProvider = getClient(apiKey, baseUrl);
+				throw new Error('Google API key is required.');
-		const model = googleProvider(modelId);
+			}
-		const result = await generateText({
+
-			model,
+			return createGoogleGenerativeAI({
-			messages,
+				apiKey,
-			temperature,
+				...(baseURL && { baseURL })
-			maxOutputTokens: maxTokens
+			});
-		});
+		} catch (error) {
-		return result.text;
+			this.handleError('client initialization', error);
-	} catch (error) {
+		}
-		log(
-			'error',
-			`Error generating text with Google (${modelId}): ${error.message}`
-		);
-		throw error;
 	}
 }
-
-/**
- * Streams text using a Google AI model.
- *
- * @param {object} params - Parameters for the streaming.
- * @param {string} params.apiKey - Google API Key.
- * @param {string} params.modelId - Specific model ID to use (overrides default).
- * @param {number} params.temperature - Generation temperature.
- * @param {Array<object>} params.messages - The conversation history.
- * @param {number} [params.maxTokens] - Optional max tokens.
- * @returns {Promise<ReadableStream>} A readable stream of text deltas.
- * @throws {Error} If API key is missing or API call fails.
- */
-async function streamGoogleText({
-	apiKey,
-	modelId = DEFAULT_MODEL,
-	temperature = DEFAULT_TEMPERATURE,
-	messages,
-	maxTokens,
-	baseUrl
-}) {
-	if (!apiKey) {
-		throw new Error('Google API key is required.');
-	}
-	log('info', `Streaming text with Google model: ${modelId}`);
-
-	try {
-		const googleProvider = getClient(apiKey, baseUrl);
-		const model = googleProvider(modelId);
-		const stream = await streamText({
-			model,
-			messages,
-			temperature,
-			maxOutputTokens: maxTokens
-		});
-		return stream;
-	} catch (error) {
-		log(
-			'error',
-			`Error streaming text with Google (${modelId}): ${error.message}`
-		);
-		throw error;
-	}
-}
-
-/**
- * Generates a structured object using a Google AI model.
- *
- * @param {object} params - Parameters for the object generation.
- * @param {string} params.apiKey - Google API Key.
- * @param {string} params.modelId - Specific model ID to use (overrides default).
- * @param {number} params.temperature - Generation temperature.
- * @param {Array<object>} params.messages - The conversation history.
- * @param {import('zod').ZodSchema} params.schema - Zod schema for the expected object.
- * @param {string} params.objectName - Name for the object generation context.
- * @param {number} [params.maxTokens] - Optional max tokens.
- * @returns {Promise<object>} The generated object matching the schema.
- * @throws {Error} If API key is missing or API call fails.
- */
-async function generateGoogleObject({
-	apiKey,
-	modelId = DEFAULT_MODEL,
-	temperature = DEFAULT_TEMPERATURE,
-	messages,
-	schema,
-	objectName, // Note: Vercel SDK might use this differently or not at all
-	maxTokens,
-	baseUrl
-}) {
-	if (!apiKey) {
-		throw new Error('Google API key is required.');
-	}
-	log('info', `Generating object with Google model: ${modelId}`);
-
-	try {
-		const googleProvider = getClient(apiKey, baseUrl);
-		const model = googleProvider(modelId);
-		const { object } = await generateObject({
-			model,
-			schema,
-			messages,
-			temperature,
-			maxOutputTokens: maxTokens
-		});
-		return object;
-	} catch (error) {
-		log(
-			'error',
-			`Error generating object with Google (${modelId}): ${error.message}`
-		);
-		throw error;
-	}
-}
-
-export { generateGoogleText, streamGoogleText, generateGoogleObject };

src/ai-providers/index.js

@@ -0,0 +1,15 @@
+/**
+ * src/ai-providers/index.js
+ * Central export point for all AI provider classes
+ */
+
+export { AnthropicAIProvider } from './anthropic.js';
+export { PerplexityAIProvider } from './perplexity.js';
+export { GoogleAIProvider } from './google.js';
+export { OpenAIProvider } from './openai.js';
+export { XAIProvider } from './xai.js';
+export { OpenRouterAIProvider } from './openrouter.js';
+export { OllamaAIProvider } from './ollama.js';
+export { BedrockAIProvider } from './bedrock.js';
+export { AzureProvider } from './azure.js';
+export { VertexAIProvider } from './google-vertex.js';

src/ai-providers/ollama.js

@@ -0,0 +1,42 @@
+/**
+ * ollama.js
+ * AI provider implementation for Ollama models using the ollama-ai-provider package.
+ */
+
+import { createOllama } from 'ollama-ai-provider';
+import { BaseAIProvider } from './base-provider.js';
+
+export class OllamaAIProvider extends BaseAIProvider {
+	constructor() {
+		super();
+		this.name = 'Ollama';
+	}
+
+	/**
+	 * Override auth validation - Ollama doesn't require API keys
+	 * @param {object} params - Parameters to validate
+	 */
+	validateAuth(_params) {
+		// Ollama runs locally and doesn't require API keys
+		// No authentication validation needed
+	}
+
+	/**
+	 * Creates and returns an Ollama client instance.
+	 * @param {object} params - Parameters for client initialization
+	 * @param {string} [params.baseURL] - Optional Ollama base URL (defaults to http://localhost:11434)
+	 * @returns {Function} Ollama client function
+	 * @throws {Error} If initialization fails
+	 */
+	getClient(params) {
+		try {
+			const { baseURL } = params;
+
+			return createOllama({
+				...(baseURL && { baseURL })
+			});
+		} catch (error) {
+			this.handleError('client initialization', error);
+		}
+	}
+}

src/ai-providers/openai.js

@@ -1,180 +1,39 @@
-import { createOpenAI } from '@ai-sdk/openai'; // Using openai provider from Vercel AI SDK
-import { generateObject } from 'ai'; // Import necessary functions from 'ai'
-import { log } from '../../scripts/modules/utils.js';
-
-function getClient(apiKey, baseUrl) {
-	if (!apiKey) {
-		throw new Error('OpenAI API key is required.');
-	}
-	return createOpenAI({
-		apiKey: apiKey,
-		...(baseUrl && { baseURL: baseUrl })
-	});
-}
-
 /**
- * Generates text using OpenAI models via Vercel AI SDK.
+ * openai.js
- *
+ * AI provider implementation for OpenAI models using Vercel AI SDK.
- * @param {object} params - Parameters including apiKey, modelId, messages, maxTokens, temperature, baseUrl.
- * @returns {Promise<string>} The generated text content.
- * @throws {Error} If API call fails.
  */
-export async function generateOpenAIText(params) {
-	const { apiKey, modelId, messages, maxTokens, temperature, baseUrl } = params;
-	log('debug', `generateOpenAIText called with model: ${modelId}`);
 
-	if (!apiKey) {
+import { createOpenAI } from '@ai-sdk/openai';
-		throw new Error('OpenAI API key is required.');
+import { BaseAIProvider } from './base-provider.js';
-	}
+
-	if (!modelId) {
+export class OpenAIProvider extends BaseAIProvider {
-		throw new Error('OpenAI Model ID is required.');
+	constructor() {
-	}
+		super();
-	if (!messages || !Array.isArray(messages) || messages.length === 0) {
+		this.name = 'OpenAI';
-		throw new Error('Invalid or empty messages array provided for OpenAI.');
 	}
 
-	const openaiClient = getClient(apiKey, baseUrl);
+	/**
+	 * Creates and returns an OpenAI client instance.
+	 * @param {object} params - Parameters for client initialization
+	 * @param {string} params.apiKey - OpenAI API key
+	 * @param {string} [params.baseURL] - Optional custom API endpoint
+	 * @returns {Function} OpenAI client function
+	 * @throws {Error} If API key is missing or initialization fails
+	 */
+	getClient(params) {
+		try {
+			const { apiKey, baseURL } = params;
 
-	try {
+			if (!apiKey) {
-		const result = await openaiClient.chat(messages, {
+				throw new Error('OpenAI API key is required.');
-			model: modelId,
+			}
-			max_tokens: maxTokens,
-			temperature
-		});
 
-		const textContent = result?.choices?.[0]?.message?.content?.trim();
+			return createOpenAI({
-
+				apiKey,
-		if (!textContent) {
+				...(baseURL && { baseURL })
-			log(
+			});
-				'warn',
+		} catch (error) {
-				'OpenAI generateText response did not contain expected content.',
+			this.handleError('client initialization', error);
-				{ result }
-			);
-			throw new Error('Failed to extract content from OpenAI response.');
 		}
-		log(
-			'debug',
-			`OpenAI generateText completed successfully for model: ${modelId}`
-		);
-		return textContent;
-	} catch (error) {
-		log(
-			'error',
-			`Error in generateOpenAIText (Model: ${modelId}): ${error.message}`,
-			{ error }
-		);
-		throw new Error(
-			`OpenAI API error during text generation: ${error.message}`
-		);
-	}
-}
-
-/**
- * Streams text using OpenAI models via Vercel AI SDK.
- *
- * @param {object} params - Parameters including apiKey, modelId, messages, maxTokens, temperature, baseUrl.
- * @returns {Promise<ReadableStream>} A readable stream of text deltas.
- * @throws {Error} If API call fails.
- */
-export async function streamOpenAIText(params) {
-	const { apiKey, modelId, messages, maxTokens, temperature, baseUrl } = params;
-	log('debug', `streamOpenAIText called with model: ${modelId}`);
-
-	if (!apiKey) {
-		throw new Error('OpenAI API key is required.');
-	}
-	if (!modelId) {
-		throw new Error('OpenAI Model ID is required.');
-	}
-	if (!messages || !Array.isArray(messages) || messages.length === 0) {
-		throw new Error(
-			'Invalid or empty messages array provided for OpenAI streaming.'
-		);
-	}
-
-	const openaiClient = getClient(apiKey, baseUrl);
-
-	try {
-		const stream = await openaiClient.chat.stream(messages, {
-			model: modelId,
-			max_tokens: maxTokens,
-			temperature
-		});
-
-		log(
-			'debug',
-			`OpenAI streamText initiated successfully for model: ${modelId}`
-		);
-		return stream;
-	} catch (error) {
-		log(
-			'error',
-			`Error initiating OpenAI stream (Model: ${modelId}): ${error.message}`,
-			{ error }
-		);
-		throw new Error(
-			`OpenAI API error during streaming initiation: ${error.message}`
-		);
-	}
-}
-
-/**
- * Generates structured objects using OpenAI models via Vercel AI SDK.
- *
- * @param {object} params - Parameters including apiKey, modelId, messages, schema, objectName, maxTokens, temperature, baseUrl.
- * @returns {Promise<object>} The generated object matching the schema.
- * @throws {Error} If API call fails or object generation fails.
- */
-export async function generateOpenAIObject(params) {
-	const {
-		apiKey,
-		modelId,
-		messages,
-		schema,
-		objectName,
-		maxTokens,
-		temperature,
-		baseUrl
-	} = params;
-	log(
-		'debug',
-		`generateOpenAIObject called with model: ${modelId}, object: ${objectName}`
-	);
-
-	if (!apiKey) throw new Error('OpenAI API key is required.');
-	if (!modelId) throw new Error('OpenAI Model ID is required.');
-	if (!messages || !Array.isArray(messages) || messages.length === 0)
-		throw new Error('Invalid messages array for OpenAI object generation.');
-	if (!schema)
-		throw new Error('Schema is required for OpenAI object generation.');
-	if (!objectName)
-		throw new Error('Object name is required for OpenAI object generation.');
-
-	const openaiClient = getClient(apiKey, baseUrl);
-
-	try {
-		const result = await generateObject({
-			model: openaiClient(modelId),
-			schema: schema,
-			messages: messages,
-			mode: 'tool',
-			maxTokens: maxTokens,
-			temperature: temperature
-		});
-
-		log(
-			'debug',
-			`OpenAI generateObject completed successfully for model: ${modelId}`
-		);
-		return result.object;
-	} catch (error) {
-		log(
-			'error',
-			`Error in generateOpenAIObject (Model: ${modelId}, Object: ${objectName}): ${error.message}`,
-			{ error }
-		);
-		throw new Error(
-			`OpenAI API error during object generation: ${error.message}`
-		);
 	}
 }

src/ai-providers/openrouter.js

@@ -1,179 +1,39 @@
+/**
+ * openrouter.js
+ * AI provider implementation for OpenRouter models using Vercel AI SDK.
+ */
+
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
-import { generateText, streamText, generateObject } from 'ai';
+import { BaseAIProvider } from './base-provider.js';
-import { log } from '../../scripts/modules/utils.js'; // Assuming utils.js is in scripts/modules
 
-function getClient(apiKey, baseUrl) {
+export class OpenRouterAIProvider extends BaseAIProvider {
-	if (!apiKey) throw new Error('OpenRouter API key is required.');
+	constructor() {
-	return createOpenRouter({
+		super();
-		apiKey,
+		this.name = 'OpenRouter';
-		...(baseUrl && { baseURL: baseUrl })
+	}
-	});
-}
 
-/**
+	/**
- * Generates text using an OpenRouter chat model.
+	 * Creates and returns an OpenRouter client instance.
- *
+	 * @param {object} params - Parameters for client initialization
- * @param {object} params - Parameters for the text generation.
+	 * @param {string} params.apiKey - OpenRouter API key
- * @param {string} params.apiKey - OpenRouter API key.
+	 * @param {string} [params.baseURL] - Optional custom API endpoint
- * @param {string} params.modelId - The OpenRouter model ID (e.g., 'anthropic/claude-3.5-sonnet').
+	 * @returns {Function} OpenRouter client function
- * @param {Array<object>} params.messages - Array of message objects (system, user, assistant).
+	 * @throws {Error} If API key is missing or initialization fails
- * @param {number} [params.maxTokens] - Maximum tokens to generate.
+	 */
- * @param {number} [params.temperature] - Sampling temperature.
+	getClient(params) {
- * @param {string} [params.baseUrl] - Base URL for the OpenRouter API.
+		try {
- * @returns {Promise<string>} The generated text content.
+			const { apiKey, baseURL } = params;
- * @throws {Error} If the API call fails.
- */
-async function generateOpenRouterText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl,
-	...rest // Capture any other Vercel AI SDK compatible parameters
-}) {
-	if (!apiKey) throw new Error('OpenRouter API key is required.');
-	if (!modelId) throw new Error('OpenRouter model ID is required.');
-	if (!messages || messages.length === 0)
-		throw new Error('Messages array cannot be empty.');
 
-	try {
+			if (!apiKey) {
-		const openrouter = getClient(apiKey, baseUrl);
+				throw new Error('OpenRouter API key is required.');
-		const model = openrouter.chat(modelId); // Assuming chat model
+			}
 
-		const { text } = await generateText({
+			return createOpenRouter({
-			model,
+				apiKey,
-			messages,
+				...(baseURL && { baseURL })
-			maxTokens,
+			});
-			temperature,
+		} catch (error) {
-			...rest // Pass any additional parameters
+			this.handleError('client initialization', error);
-		});
+		}
-		return text;
-	} catch (error) {
-		log(
-			'error',
-			`OpenRouter generateText failed for model ${modelId}: ${error.message}`
-		);
-		// Re-throw the error for the unified layer to handle retries/fallbacks
-		throw error;
 	}
 }
-
-/**
- * Streams text using an OpenRouter chat model.
- *
- * @param {object} params - Parameters for the text streaming.
- * @param {string} params.apiKey - OpenRouter API key.
- * @param {string} params.modelId - The OpenRouter model ID (e.g., 'anthropic/claude-3.5-sonnet').
- * @param {Array<object>} params.messages - Array of message objects (system, user, assistant).
- * @param {number} [params.maxTokens] - Maximum tokens to generate.
- * @param {number} [params.temperature] - Sampling temperature.
- * @param {string} [params.baseUrl] - Base URL for the OpenRouter API.
- * @returns {Promise<ReadableStream<string>>} A readable stream of text deltas.
- * @throws {Error} If the API call fails.
- */
-async function streamOpenRouterText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl,
-	...rest
-}) {
-	if (!apiKey) throw new Error('OpenRouter API key is required.');
-	if (!modelId) throw new Error('OpenRouter model ID is required.');
-	if (!messages || messages.length === 0)
-		throw new Error('Messages array cannot be empty.');
-
-	try {
-		const openrouter = getClient(apiKey, baseUrl);
-		const model = openrouter.chat(modelId);
-
-		// Directly return the stream from the Vercel AI SDK function
-		const stream = await streamText({
-			model,
-			messages,
-			maxTokens,
-			temperature,
-			...rest
-		});
-		return stream;
-	} catch (error) {
-		log(
-			'error',
-			`OpenRouter streamText failed for model ${modelId}: ${error.message}`
-		);
-		throw error;
-	}
-}
-
-/**
- * Generates a structured object using an OpenRouter chat model.
- *
- * @param {object} params - Parameters for object generation.
- * @param {string} params.apiKey - OpenRouter API key.
- * @param {string} params.modelId - The OpenRouter model ID.
- * @param {import('zod').ZodSchema} params.schema - The Zod schema for the expected object.
- * @param {Array<object>} params.messages - Array of message objects.
- * @param {string} [params.objectName='generated_object'] - Name for object/tool.
- * @param {number} [params.maxRetries=3] - Max retries for object generation.
- * @param {number} [params.maxTokens] - Maximum tokens.
- * @param {number} [params.temperature] - Temperature.
- * @param {string} [params.baseUrl] - Base URL for the OpenRouter API.
- * @returns {Promise<object>} The generated object matching the schema.
- * @throws {Error} If the API call fails or validation fails.
- */
-async function generateOpenRouterObject({
-	apiKey,
-	modelId,
-	schema,
-	messages,
-	objectName = 'generated_object',
-	maxRetries = 3,
-	maxTokens,
-	temperature,
-	baseUrl,
-	...rest
-}) {
-	if (!apiKey) throw new Error('OpenRouter API key is required.');
-	if (!modelId) throw new Error('OpenRouter model ID is required.');
-	if (!schema) throw new Error('Zod schema is required for object generation.');
-	if (!messages || messages.length === 0)
-		throw new Error('Messages array cannot be empty.');
-
-	try {
-		const openrouter = getClient(apiKey, baseUrl);
-		const model = openrouter.chat(modelId);
-
-		const { object } = await generateObject({
-			model,
-			schema,
-			mode: 'tool', // Standard mode for most object generation
-			tool: {
-				// Define the tool based on the schema
-				name: objectName,
-				description: `Generate an object conforming to the ${objectName} schema.`,
-				parameters: schema
-			},
-			messages,
-			maxTokens,
-			temperature,
-			maxRetries, // Pass maxRetries if supported by generateObject
-			...rest
-		});
-		return object;
-	} catch (error) {
-		log(
-			'error',
-			`OpenRouter generateObject failed for model ${modelId}: ${error.message}`
-		);
-		throw error;
-	}
-}
-
-export {
-	generateOpenRouterText,
-	streamOpenRouterText,
-	generateOpenRouterObject
-};

src/ai-providers/perplexity.js

@@ -1,168 +1,39 @@
 /**
- * src/ai-providers/perplexity.js
+ * perplexity.js
- *
+ * AI provider implementation for Perplexity models using Vercel AI SDK.
- * Implementation for interacting with Perplexity models
- * using the Vercel AI SDK.
  */
+
 import { createPerplexity } from '@ai-sdk/perplexity';
-import { generateText, streamText, generateObject, streamObject } from 'ai';
+import { BaseAIProvider } from './base-provider.js';
-import { log } from '../../scripts/modules/utils.js';
 
-// --- Client Instantiation ---
+export class PerplexityAIProvider extends BaseAIProvider {
-// Similar to Anthropic, this expects the resolved API key to be passed in.
+	constructor() {
-function getClient(apiKey, baseUrl) {
+		super();
-	if (!apiKey) {
+		this.name = 'Perplexity';
-		throw new Error('Perplexity API key is required.');
 	}
-	return createPerplexity({
-		apiKey: apiKey,
-		...(baseUrl && { baseURL: baseUrl })
-	});
-}
 
-// --- Standardized Service Function Implementations ---
+	/**
+	 * Creates and returns a Perplexity client instance.
+	 * @param {object} params - Parameters for client initialization
+	 * @param {string} params.apiKey - Perplexity API key
+	 * @param {string} [params.baseURL] - Optional custom API endpoint
+	 * @returns {Function} Perplexity client function
+	 * @throws {Error} If API key is missing or initialization fails
+	 */
+	getClient(params) {
+		try {
+			const { apiKey, baseURL } = params;
 
-/**
+			if (!apiKey) {
- * Generates text using a Perplexity model.
+				throw new Error('Perplexity API key is required.');
- *
+			}
- * @param {object} params - Parameters for the text generation.
+
- * @param {string} params.apiKey - The Perplexity API key.
+			return createPerplexity({
- * @param {string} params.modelId - The specific Perplexity model ID.
+				apiKey,
- * @param {Array<object>} params.messages - The messages array.
+				baseURL: baseURL || 'https://api.perplexity.ai'
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
+			});
- * @param {number} [params.temperature] - Temperature for generation.
+		} catch (error) {
- * @param {string} [params.baseUrl] - Base URL for the Perplexity API.
+			this.handleError('client initialization', error);
- * @returns {Promise<string>} The generated text content.
+		}
- * @throws {Error} If the API call fails.
- */
-export async function generatePerplexityText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl
-}) {
-	log('debug', `Generating Perplexity text with model: ${modelId}`);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		const result = await generateText({
-			model: client(modelId),
-			messages: messages,
-			maxTokens: maxTokens,
-			temperature: temperature
-		});
-		log(
-			'debug',
-			`Perplexity generateText result received. Tokens: ${result.usage.completionTokens}/${result.usage.promptTokens}`
-		);
-		return result.text;
-	} catch (error) {
-		log('error', `Perplexity generateText failed: ${error.message}`);
-		throw error;
 	}
 }
-
-/**
- * Streams text using a Perplexity model.
- *
- * @param {object} params - Parameters for the text streaming.
- * @param {string} params.apiKey - The Perplexity API key.
- * @param {string} params.modelId - The specific Perplexity model ID.
- * @param {Array<object>} params.messages - The messages array.
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
- * @param {number} [params.temperature] - Temperature for generation.
- * @param {string} [params.baseUrl] - Base URL for the Perplexity API.
- * @returns {Promise<object>} The full stream result object from the Vercel AI SDK.
- * @throws {Error} If the API call fails to initiate the stream.
- */
-export async function streamPerplexityText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl
-}) {
-	log('debug', `Streaming Perplexity text with model: ${modelId}`);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		const stream = await streamText({
-			model: client(modelId),
-			messages: messages,
-			maxTokens: maxTokens,
-			temperature: temperature
-		});
-		return stream;
-	} catch (error) {
-		log('error', `Perplexity streamText failed: ${error.message}`);
-		throw error;
-	}
-}
-
-/**
- * Generates a structured object using a Perplexity model.
- * Note: Perplexity API might not directly support structured object generation
- * in the same way as OpenAI or Anthropic. This function might need
- * adjustments or might not be feasible depending on the model's capabilities
- * and the Vercel AI SDK's support for Perplexity in this context.
- *
- * @param {object} params - Parameters for object generation.
- * @param {string} params.apiKey - The Perplexity API key.
- * @param {string} params.modelId - The specific Perplexity model ID.
- * @param {Array<object>} params.messages - The messages array.
- * @param {import('zod').ZodSchema} params.schema - The Zod schema for the object.
- * @param {string} params.objectName - A name for the object/tool.
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
- * @param {number} [params.temperature] - Temperature for generation.
- * @param {number} [params.maxRetries] - Max retries for validation/generation.
- * @param {string} [params.baseUrl] - Base URL for the Perplexity API.
- * @returns {Promise<object>} The generated object matching the schema.
- * @throws {Error} If generation or validation fails or is unsupported.
- */
-export async function generatePerplexityObject({
-	apiKey,
-	modelId,
-	messages,
-	schema,
-	objectName = 'generated_object',
-	maxTokens,
-	temperature,
-	maxRetries = 1,
-	baseUrl
-}) {
-	log(
-		'debug',
-		`Attempting to generate Perplexity object ('${objectName}') with model: ${modelId}`
-	);
-	log(
-		'warn',
-		'generateObject support for Perplexity might be limited or experimental.'
-	);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		const result = await generateObject({
-			model: client(modelId),
-			schema: schema,
-			messages: messages,
-			maxTokens: maxTokens,
-			temperature: temperature,
-			maxRetries: maxRetries
-		});
-		log(
-			'debug',
-			`Perplexity generateObject result received. Tokens: ${result.usage.completionTokens}/${result.usage.promptTokens}`
-		);
-		return result.object;
-	} catch (error) {
-		log(
-			'error',
-			`Perplexity generateObject ('${objectName}') failed: ${error.message}`
-		);
-		throw new Error(
-			`Failed to generate object with Perplexity: ${error.message}. Structured output might not be fully supported.`
-		);
-	}
-}
-
-// TODO: Implement streamPerplexityObject if needed and feasible.

src/ai-providers/xai.js

@@ -1,163 +1,39 @@
 /**
- * src/ai-providers/xai.js
+ * xai.js
- *
+ * AI provider implementation for xAI models using Vercel AI SDK.
- * Implementation for interacting with xAI models (e.g., Grok)
- * using the Vercel AI SDK.
  */
+
 import { createXai } from '@ai-sdk/xai';
-import { generateText, streamText, generateObject } from 'ai'; // Only import what's used
+import { BaseAIProvider } from './base-provider.js';
-import { log } from '../../scripts/modules/utils.js'; // Assuming utils is accessible
 
-// --- Client Instantiation ---
+export class XAIProvider extends BaseAIProvider {
-function getClient(apiKey, baseUrl) {
+	constructor() {
-	if (!apiKey) {
+		super();
-		throw new Error('xAI API key is required.');
+		this.name = 'xAI';
 	}
-	return createXai({
-		apiKey: apiKey,
-		...(baseUrl && { baseURL: baseUrl })
-	});
-}
 
-// --- Standardized Service Function Implementations ---
+	/**
+	 * Creates and returns an xAI client instance.
+	 * @param {object} params - Parameters for client initialization
+	 * @param {string} params.apiKey - xAI API key
+	 * @param {string} [params.baseURL] - Optional custom API endpoint
+	 * @returns {Function} xAI client function
+	 * @throws {Error} If API key is missing or initialization fails
+	 */
+	getClient(params) {
+		try {
+			const { apiKey, baseURL } = params;
 
-/**
+			if (!apiKey) {
- * Generates text using an xAI model.
+				throw new Error('xAI API key is required.');
- *
+			}
- * @param {object} params - Parameters for the text generation.
+
- * @param {string} params.apiKey - The xAI API key.
+			return createXai({
- * @param {string} params.modelId - The specific xAI model ID (e.g., 'grok-3').
+				apiKey,
- * @param {Array<object>} params.messages - The messages array (e.g., [{ role: 'user', content: '...' }]).
+				baseURL: baseURL || 'https://api.x.ai/v1'
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
+			});
- * @param {number} [params.temperature] - Temperature for generation.
+		} catch (error) {
- * @param {string} [params.baseUrl] - The base URL for the xAI API.
+			this.handleError('client initialization', error);
- * @returns {Promise<string>} The generated text content.
+		}
- * @throws {Error} If the API call fails.
- */
-export async function generateXaiText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl
-}) {
-	log('debug', `Generating xAI text with model: ${modelId}`);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		const result = await generateText({
-			model: client(modelId),
-			messages: messages,
-			maxTokens: maxTokens,
-			temperature: temperature
-		});
-		log(
-			'debug',
-			`xAI generateText result received. Tokens: ${result.usage.completionTokens}/${result.usage.promptTokens}`
-		);
-		return result.text;
-	} catch (error) {
-		log('error', `xAI generateText failed: ${error.message}`);
-		throw error;
-	}
-}
-
-/**
- * Streams text using an xAI model.
- *
- * @param {object} params - Parameters for the text streaming.
- * @param {string} params.apiKey - The xAI API key.
- * @param {string} params.modelId - The specific xAI model ID.
- * @param {Array<object>} params.messages - The messages array.
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
- * @param {number} [params.temperature] - Temperature for generation.
- * @param {string} [params.baseUrl] - The base URL for the xAI API.
- * @returns {Promise<object>} The full stream result object from the Vercel AI SDK.
- * @throws {Error} If the API call fails to initiate the stream.
- */
-export async function streamXaiText({
-	apiKey,
-	modelId,
-	messages,
-	maxTokens,
-	temperature,
-	baseUrl
-}) {
-	log('debug', `Streaming xAI text with model: ${modelId}`);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		const stream = await streamText({
-			model: client(modelId),
-			messages: messages,
-			maxTokens: maxTokens,
-			temperature: temperature
-		});
-		return stream;
-	} catch (error) {
-		log('error', `xAI streamText failed: ${error.message}`, error.stack);
-		throw error;
-	}
-}
-
-/**
- * Generates a structured object using an xAI model.
- * Note: Based on search results, xAI models do not currently support Object Generation.
- * This function is included for structural consistency but will likely fail if called.
- *
- * @param {object} params - Parameters for object generation.
- * @param {string} params.apiKey - The xAI API key.
- * @param {string} params.modelId - The specific xAI model ID.
- * @param {Array<object>} params.messages - The messages array.
- * @param {import('zod').ZodSchema} params.schema - The Zod schema for the object.
- * @param {string} params.objectName - A name for the object/tool.
- * @param {number} [params.maxTokens] - Maximum tokens for the response.
- * @param {number} [params.temperature] - Temperature for generation.
- * @param {number} [params.maxRetries] - Max retries for validation/generation.
- * @param {string} [params.baseUrl] - The base URL for the xAI API.
- * @returns {Promise<object>} The generated object matching the schema.
- * @throws {Error} If generation or validation fails.
- */
-export async function generateXaiObject({
-	apiKey,
-	modelId,
-	messages,
-	schema,
-	objectName = 'generated_xai_object',
-	maxTokens,
-	temperature,
-	maxRetries = 3,
-	baseUrl
-}) {
-	log(
-		'warn',
-		`Attempting to generate xAI object ('${objectName}') with model: ${modelId}. This may not be supported by the provider.`
-	);
-	try {
-		const client = getClient(apiKey, baseUrl);
-		const result = await generateObject({
-			model: client(modelId),
-			// Note: mode might need adjustment if xAI ever supports object generation differently
-			mode: 'tool',
-			schema: schema,
-			messages: messages,
-			tool: {
-				name: objectName,
-				description: `Generate a ${objectName} based on the prompt.`
-			},
-			maxTokens: maxTokens,
-			temperature: temperature,
-			maxRetries: maxRetries
-		});
-		log(
-			'debug',
-			`xAI generateObject result received. Tokens: ${result.usage.completionTokens}/${result.usage.promptTokens}`
-		);
-		return result.object;
-	} catch (error) {
-		log(
-			'error',
-			`xAI generateObject ('${objectName}') failed: ${error.message}. (Likely unsupported by provider)`
-		);
-		throw error;
 	}
 }

tasks/task_024.txt

@@ -58,6 +58,50 @@ Testing approach:
 - Test parameter validation (missing ID, invalid ID format)
 - Test error handling for non-existent task IDs
 - Test basic command flow with a mock task store
+<info added on 2025-05-23T21:02:03.909Z>
+## Updated Implementation Approach
+
+Based on code review findings, the implementation approach needs to be revised:
+
+1. Implement the command in `scripts/modules/commands.js` instead of creating a new file
+2. Add command registration in the `registerCommands()` function (around line 482)
+3. Follow existing command structure pattern:
+   ```javascript
+   programInstance
+       .command('generate-test')
+       .description('Generate test cases for a task using AI')
+       .option('-f, --file <file>', 'Path to the tasks file', 'tasks/tasks.json')
+       .option('-i, --id <id>', 'Task ID parameter')
+       .option('-p, --prompt <text>', 'Additional prompt context')
+       .option('-r, --research', 'Use research model')
+       .action(async (options) => {
+           // Implementation
+       });
+   ```
+
+4. Use the following utilities:
+   - `findProjectRoot()` for resolving project paths
+   - `findTaskById()` for retrieving task data
+   - `chalk` for formatted console output
+
+5. Implement error handling following the pattern:
+   ```javascript
+   try {
+       // Implementation
+   } catch (error) {
+       console.error(chalk.red(`Error generating test: ${error.message}`));
+       if (error.details) {
+           console.error(chalk.red(error.details));
+       }
+       process.exit(1);
+   }
+   ```
+
+6. Required imports:
+   - chalk for colored output
+   - path for file path operations
+   - findProjectRoot and findTaskById from './utils.js'
+</info added on 2025-05-23T21:02:03.909Z>
 
 ## 2. Implement AI prompt construction and FastMCP integration [pending]
 ### Dependencies: 24.1
@@ -76,6 +120,50 @@ Testing approach:
 - Test FastMCP integration with mocked responses
 - Test error handling for FastMCP failures
 - Test response processing with sample FastMCP outputs
+<info added on 2025-05-23T21:04:33.890Z>
+## AI Integration Implementation
+
+### AI Service Integration
+- Use the unified AI service layer, not FastMCP directly
+- Implement with `generateObjectService` from '../ai-services-unified.js'
+- Define Zod schema for structured test generation output:
+  - testContent: Complete Jest test file content
+  - fileName: Suggested filename for the test file
+  - mockRequirements: External dependencies that need mocking
+
+### Prompt Construction
+- Create system prompt defining AI's role as test generator
+- Build user prompt with task context (ID, title, description, details)
+- Include test strategy and subtasks context in the prompt
+- Follow patterns from add-task.js for prompt structure
+
+### Task Analysis
+- Retrieve task data using `findTaskById()` from utils.js
+- Build context by analyzing task description, details, and testStrategy
+- Examine project structure for import patterns
+- Parse specific testing requirements from task.testStrategy field
+
+### File System Operations
+- Determine output path in same directory as tasks.json
+- Generate standardized filename based on task ID
+- Use fs.writeFileSync for writing test content to file
+
+### Error Handling & UI
+- Implement try/catch blocks for AI service calls
+- Display user-friendly error messages with chalk
+- Use loading indicators during AI processing
+- Support both research and main AI models
+
+### Telemetry
+- Pass through telemetryData from AI service response
+- Display AI usage summary for CLI output
+
+### Required Dependencies
+- generateObjectService from ai-services-unified.js
+- UI components (loading indicators, display functions)
+- Zod for schema validation
+- Chalk for formatted console output
+</info added on 2025-05-23T21:04:33.890Z>
 
 ## 3. Implement test file generation and output [pending]
 ### Dependencies: 24.2
@@ -97,4 +185,419 @@ Testing approach:
 - Test file system operations with mocked fs module
 - Test the complete flow from command input to file output
 - Verify generated tests can be executed by Jest
+<info added on 2025-05-23T21:06:32.457Z>
+## Detailed Implementation Guidelines
+
+### File Naming Convention Implementation
+```javascript
+function generateTestFileName(taskId, isSubtask = false) {
+  if (isSubtask) {
+    // For subtasks like "24.1", generate "task_024_001.test.js"
+    const [parentId, subtaskId] = taskId.split('.');
+    return `task_${parentId.padStart(3, '0')}_${subtaskId.padStart(3, '0')}.test.js`;
+  } else {
+    // For parent tasks like "24", generate "task_024.test.js"
+    return `task_${taskId.toString().padStart(3, '0')}.test.js`;
+  }
+}
+```
+
+### File Location Strategy
+- Place generated test files in the `tasks/` directory alongside task files
+- This ensures co-location with task documentation and simplifies implementation
+
+### File Content Structure Template
+```javascript
+/**
+ * Test file for Task ${taskId}: ${taskTitle}
+ * Generated automatically by Task Master
+ */
+
+import { jest } from '@jest/globals';
+// Additional imports based on task requirements
+
+describe('Task ${taskId}: ${taskTitle}', () => {
+  beforeEach(() => {
+    // Setup code
+  });
+
+  afterEach(() => {
+    // Cleanup code
+  });
+
+  test('should ${testDescription}', () => {
+    // Test implementation
+  });
+});
+```
+
+### Code Formatting Standards
+- Follow project's .prettierrc configuration:
+  - Tab width: 2 spaces (useTabs: true)
+  - Print width: 80 characters
+  - Semicolons: Required (semi: true)
+  - Quotes: Single quotes (singleQuote: true)
+  - Trailing commas: None (trailingComma: "none")
+  - Bracket spacing: True
+  - Arrow parens: Always
+
+### File System Operations Implementation
+```javascript
+import fs from 'fs';
+import path from 'path';
+
+// Determine output path
+const tasksDir = path.dirname(tasksPath); // Same directory as tasks.json
+const fileName = generateTestFileName(task.id, isSubtask);
+const filePath = path.join(tasksDir, fileName);
+
+// Ensure directory exists
+if (!fs.existsSync(tasksDir)) {
+  fs.mkdirSync(tasksDir, { recursive: true });
+}
+
+// Write test file with proper error handling
+try {
+  fs.writeFileSync(filePath, formattedTestContent, 'utf8');
+} catch (error) {
+  throw new Error(`Failed to write test file: ${error.message}`);
+}
+```
+
+### Error Handling for File Operations
+```javascript
+try {
+  // File writing operation
+  fs.writeFileSync(filePath, testContent, 'utf8');
+} catch (error) {
+  if (error.code === 'ENOENT') {
+    throw new Error(`Directory does not exist: ${path.dirname(filePath)}`);
+  } else if (error.code === 'EACCES') {
+    throw new Error(`Permission denied writing to: ${filePath}`);
+  } else if (error.code === 'ENOSPC') {
+    throw new Error('Insufficient disk space to write test file');
+  } else {
+    throw new Error(`Failed to write test file: ${error.message}`);
+  }
+}
+```
+
+### User Feedback Implementation
+```javascript
+// Success feedback
+console.log(chalk.green('✅ Test file generated successfully:'));
+console.log(chalk.cyan(`   File: ${fileName}`));
+console.log(chalk.cyan(`   Location: ${filePath}`));
+console.log(chalk.gray(`   Size: ${testContent.length} characters`));
+
+// Additional info
+if (mockRequirements && mockRequirements.length > 0) {
+  console.log(chalk.yellow(`   Mocks needed: ${mockRequirements.join(', ')}`));
+}
+```
+
+### Content Validation Requirements
+1. Jest Syntax Validation:
+   - Ensure proper describe/test structure
+   - Validate import statements
+   - Check for balanced brackets and parentheses
+
+2. Code Quality Checks:
+   - Verify no syntax errors
+   - Ensure proper indentation
+   - Check for required imports
+
+3. Test Completeness:
+   - At least one test case
+   - Proper test descriptions
+   - Appropriate assertions
+
+### Required Dependencies
+```javascript
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { log } from '../utils.js';
+```
+
+### Integration with Existing Patterns
+Follow the pattern from `generate-task-files.js`:
+1. Read task data using existing utilities
+2. Process content with proper formatting
+3. Write files with error handling
+4. Provide feedback to user
+5. Return success data for MCP integration
+</info added on 2025-05-23T21:06:32.457Z>
+<info added on 2025-05-23T21:18:25.369Z>
+## Corrected Implementation Approach
+
+### Updated File Location Strategy
+
+**CORRECTION**: Tests should go in `/tests/` directory, not `/tasks/` directory.
+
+Based on Jest configuration analysis:
+- Jest is configured with `roots: ['<rootDir>/tests']`
+- Test pattern: `**/?(*.)+(spec|test).js`
+- Current test structure has `/tests/unit/`, `/tests/integration/`, etc.
+
+### Recommended Directory Structure:
+```
+tests/
+├── unit/                    # Manual unit tests
+├── integration/             # Manual integration tests  
+├── generated/               # AI-generated tests
+│   ├── tasks/              # Generated task tests
+│   │   ├── task_024.test.js
+│   │   └── task_024_001.test.js
+│   └── README.md           # Explains generated tests
+└── fixtures/               # Test fixtures
+```
+
+### Updated File Path Logic:
+```javascript
+// Determine output path - place in tests/generated/tasks/
+const projectRoot = findProjectRoot() || '.';
+const testsDir = path.join(projectRoot, 'tests', 'generated', 'tasks');
+const fileName = generateTestFileName(task.id, isSubtask);
+const filePath = path.join(testsDir, fileName);
+
+// Ensure directory structure exists
+if (!fs.existsSync(testsDir)) {
+    fs.mkdirSync(testsDir, { recursive: true });
+}
+```
+
+### Testing Framework Configuration
+
+The generate-test command should read the configured testing framework from `.taskmasterconfig`:
+
+```javascript
+// Read testing framework from config
+const config = getConfig(projectRoot);
+const testingFramework = config.testingFramework || 'jest'; // Default to Jest
+
+// Generate different templates based on framework
+switch (testingFramework) {
+    case 'jest':
+        return generateJestTest(task, context);
+    case 'mocha':
+        return generateMochaTest(task, context);
+    case 'vitest':
+        return generateVitestTest(task, context);
+    default:
+        throw new Error(`Unsupported testing framework: ${testingFramework}`);
+}
+```
+
+### Framework-Specific Templates
+
+**Jest Template** (current):
+```javascript
+/**
+ * Test file for Task ${taskId}: ${taskTitle}
+ * Generated automatically by Task Master
+ */
+
+import { jest } from '@jest/globals';
+// Task-specific imports
+
+describe('Task ${taskId}: ${taskTitle}', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('should ${testDescription}', () => {
+        // Test implementation
+    });
+});
+```
+
+**Mocha Template**:
+```javascript
+/**
+ * Test file for Task ${taskId}: ${taskTitle}
+ * Generated automatically by Task Master
+ */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+// Task-specific imports
+
+describe('Task ${taskId}: ${taskTitle}', () => {
+    beforeEach(() => {
+        sinon.restore();
+    });
+
+    it('should ${testDescription}', () => {
+        // Test implementation
+    });
+});
+```
+
+**Vitest Template**:
+```javascript
+/**
+ * Test file for Task ${taskId}: ${taskTitle}
+ * Generated automatically by Task Master
+ */
+
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+// Task-specific imports
+
+describe('Task ${taskId}: ${taskTitle}', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should ${testDescription}', () => {
+        // Test implementation
+    });
+});
+```
+
+### AI Prompt Enhancement for Mocking
+
+To address the mocking challenge, enhance the AI prompt with project context:
+
+```javascript
+const systemPrompt = `You are an expert at generating comprehensive test files. When generating tests, pay special attention to mocking external dependencies correctly.
+
+CRITICAL MOCKING GUIDELINES:
+1. Analyze the task requirements to identify external dependencies (APIs, databases, file system, etc.)
+2. Mock external dependencies at the module level, not inline
+3. Use the testing framework's mocking utilities (jest.mock(), sinon.stub(), vi.mock())
+4. Create realistic mock data that matches the expected API responses
+5. Test both success and error scenarios for mocked dependencies
+6. Ensure mocks are cleared between tests to prevent test pollution
+
+Testing Framework: ${testingFramework}
+Project Structure: ${projectStructureContext}
+`;
+```
+
+### Integration with Future Features
+
+This primitive command design enables:
+1. **Automatic test generation**: `task-master add-task --with-test`
+2. **Batch test generation**: `task-master generate-tests --all`
+3. **Framework-agnostic**: Support multiple testing frameworks
+4. **Smart mocking**: LLM analyzes dependencies and generates appropriate mocks
+
+### Updated Implementation Requirements:
+
+1. **Read testing framework** from `.taskmasterconfig`
+2. **Create tests directory structure** if it doesn't exist
+3. **Generate framework-specific templates** based on configuration
+4. **Enhanced AI prompts** with mocking best practices
+5. **Project structure analysis** for better import resolution
+6. **Mock dependency detection** from task requirements
+</info added on 2025-05-23T21:18:25.369Z>
+
+## 4. Implement MCP tool integration for generate-test command [pending]
+### Dependencies: 24.3
+### Description: Create MCP server tool support for the generate-test command to enable integration with Claude Code and other MCP clients.
+### Details:
+Implementation steps:
+1. Create direct function wrapper in mcp-server/src/core/direct-functions/
+2. Create MCP tool registration in mcp-server/src/tools/
+3. Add tool to the main tools index
+4. Implement proper parameter validation and error handling
+5. Ensure telemetry data is properly passed through
+6. Add tool to MCP server registration
+
+The MCP tool should support the same parameters as the CLI command:
+- id: Task ID to generate tests for
+- file: Path to tasks.json file
+- research: Whether to use research model
+- prompt: Additional context for test generation
+
+Follow the existing pattern from other MCP tools like add-task.js and expand-task.js.
+
+## 5. Add testing framework configuration to project initialization [pending]
+### Dependencies: 24.3
+### Description: Enhance the init.js process to let users choose their preferred testing framework (Jest, Mocha, Vitest, etc.) and store this choice in .taskmasterconfig for use by the generate-test command.
+### Details:
+Implementation requirements:
+
+1. **Add Testing Framework Prompt to init.js**:
+   - Add interactive prompt asking users to choose testing framework
+   - Support Jest (default), Mocha + Chai, Vitest, Ava, Jasmine
+   - Include brief descriptions of each framework
+   - Allow --testing-framework flag for non-interactive mode
+
+2. **Update .taskmasterconfig Template**:
+   - Add testingFramework field to configuration file
+   - Include default dependencies for each framework
+   - Store framework-specific configuration options
+
+3. **Framework-Specific Setup**:
+   - Generate appropriate config files (jest.config.js, vitest.config.ts, etc.)
+   - Add framework dependencies to package.json suggestions
+   - Create sample test file for the chosen framework
+
+4. **Integration Points**:
+   - Ensure generate-test command reads testingFramework from config
+   - Add validation to prevent conflicts between framework choices
+   - Support switching frameworks later via models command or separate config command
+
+This makes the generate-test command truly framework-agnostic and sets up the foundation for --with-test flags in other commands.
+<info added on 2025-05-23T21:22:02.048Z>
+# Implementation Plan for Testing Framework Integration
+
+## Code Structure
+
+### 1. Update init.js
+- Add testing framework prompt after addAliases prompt
+- Implement framework selection with descriptions
+- Support non-interactive mode with --testing-framework flag
+- Create setupTestingFramework() function to handle framework-specific setup
+
+### 2. Create New Module Files
+- Create `scripts/modules/testing-frameworks.js` for framework templates and setup
+- Add sample test generators for each supported framework
+- Implement config file generation for each framework
+
+### 3. Update Configuration Templates
+- Modify `assets/.taskmasterconfig` to include testing fields:
+  ```json
+  "testingFramework": "{{testingFramework}}",
+  "testingConfig": {
+    "framework": "{{testingFramework}}",
+    "setupFiles": [],
+    "testDirectory": "tests",
+    "testPattern": "**/*.test.js",
+    "coverage": {
+      "enabled": false,
+      "threshold": 80
+    }
+  }
+  ```
+
+### 4. Create Framework-Specific Templates
+- `assets/jest.config.template.js`
+- `assets/vitest.config.template.ts`
+- `assets/.mocharc.template.json`
+- `assets/ava.config.template.js`
+- `assets/jasmine.json.template`
+
+### 5. Update commands.js
+- Add `--testing-framework <framework>` option to init command
+- Add validation for supported frameworks
+
+## Error Handling
+- Validate selected framework against supported list
+- Handle existing config files gracefully with warning/overwrite prompt
+- Provide recovery options if framework setup fails
+- Add conflict detection for multiple testing frameworks
+
+## Integration Points
+- Ensure generate-test command reads testingFramework from config
+- Prepare for future --with-test flag in other commands
+- Support framework switching via config command
+
+## Testing Requirements
+- Unit tests for framework selection logic
+- Integration tests for config file generation
+- Validation tests for each supported framework
+</info added on 2025-05-23T21:22:02.048Z>