feat: enhance docs with AI agent selection and improved getting started

- Add AI agent selection page with visual cards and logos
- Create dedicated setup guides for Cursor, Claude Code, and CLI
- Move Windows-specific MCP config from README to docs
- Enhance quick-start page with agent selection flow
- Improve user experience with clear visual hierarchy

Co-authored-by: Ralph Khreish <Crunchyman-ralph@users.noreply.github.com>

.changeset/config.json

@@ -11,9 +11,6 @@
   "access": "public",
   "baseBranch": "main",
   "ignore": [
-    "docs",
-    "@tm/cli",
-    "@tm/core",
-    "@tm/build-config"
+    "docs"
   ]
 }

.changeset/easy-deer-heal.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Testing one more pre-release iteration

.changeset/moody-oranges-slide.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Test out the RC

.changeset/odd-otters-tan.md

@@ -1,5 +0,0 @@
----
-"@tm/cli": minor
----
-
-testing this stuff out to see how the release candidate works with monorepo

.changeset/pre.json

@@ -1,18 +0,0 @@
-{
-  "mode": "pre",
-  "tag": "rc",
-  "initialVersions": {
-    "task-master-ai": "0.26.0",
-    "@tm/cli": "0.26.0",
-    "docs": "0.0.2",
-    "extension": "0.24.2",
-    "@tm/build-config": "1.0.0",
-    "@tm/core": "0.26.0"
-  },
-  "changesets": [
-    "easy-deer-heal",
-    "moody-oranges-slide",
-    "odd-otters-tan",
-    "wild-ears-look"
-  ]
-}

.changeset/shiny-regions-teach.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": major
----
-
-@tm/cli: add auto-update functionality to every command

.changeset/wild-ears-look.md

@@ -1,5 +0,0 @@
----
-"extension": minor
----
-
-Added a Start Build button to the VSCODE Task Properties Right Panel

.cursor/mcp.json

@@ -2,7 +2,7 @@
 	"mcpServers": {
 		"task-master-ai": {
 			"command": "node",
-			"args": ["./mcp-server/server.js"],
+			"args": ["./dist/mcp-server.js"],
 			"env": {
 				"ANTHROPIC_API_KEY": "ANTHROPIC_API_KEY_HERE",
 				"PERPLEXITY_API_KEY": "PERPLEXITY_API_KEY_HERE",

.github/scripts/parse-metrics.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync, writeFileSync } from 'fs';
+
+function parseMetricsTable(content, metricName) {
+	const lines = content.split('\n');
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		// Match a markdown table row like: | Metric Name | value | ...
+		const safeName = metricName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+		const re = new RegExp(`^\\|\\s*${safeName}\\s*\\|\\s*([^|]+)\\|?`);
+		const match = line.match(re);
+		if (match) {
+			return match[1].trim() || 'N/A';
+		}
+	}
+	return 'N/A';
+}
+
+function parseCountMetric(content, metricName) {
+	const result = parseMetricsTable(content, metricName);
+	// Extract number from string, handling commas and spaces
+	const numberMatch = result.toString().match(/[\d,]+/);
+	if (numberMatch) {
+		const number = parseInt(numberMatch[0].replace(/,/g, ''));
+		return isNaN(number) ? 0 : number;
+	}
+	return 0;
+}
+
+function main() {
+	const metrics = {
+		issues_created: 0,
+		issues_closed: 0,
+		prs_created: 0,
+		prs_merged: 0,
+		issue_avg_first_response: 'N/A',
+		issue_avg_time_to_close: 'N/A',
+		pr_avg_first_response: 'N/A',
+		pr_avg_merge_time: 'N/A'
+	};
+
+	// Parse issue metrics
+	if (existsSync('issue_metrics.md')) {
+		console.log('📄 Found issue_metrics.md, parsing...');
+		const issueContent = readFileSync('issue_metrics.md', 'utf8');
+
+		metrics.issues_created = parseCountMetric(
+			issueContent,
+			'Total number of items created'
+		);
+		metrics.issues_closed = parseCountMetric(
+			issueContent,
+			'Number of items closed'
+		);
+		metrics.issue_avg_first_response = parseMetricsTable(
+			issueContent,
+			'Time to first response'
+		);
+		metrics.issue_avg_time_to_close = parseMetricsTable(
+			issueContent,
+			'Time to close'
+		);
+	} else {
+		console.warn('[parse-metrics] issue_metrics.md not found; using defaults.');
+	}
+
+	// Parse PR created metrics
+	if (existsSync('pr_created_metrics.md')) {
+		console.log('📄 Found pr_created_metrics.md, parsing...');
+		const prCreatedContent = readFileSync('pr_created_metrics.md', 'utf8');
+
+		metrics.prs_created = parseCountMetric(
+			prCreatedContent,
+			'Total number of items created'
+		);
+		metrics.pr_avg_first_response = parseMetricsTable(
+			prCreatedContent,
+			'Time to first response'
+		);
+	} else {
+		console.warn(
+			'[parse-metrics] pr_created_metrics.md not found; using defaults.'
+		);
+	}
+
+	// Parse PR merged metrics (for more accurate merge data)
+	if (existsSync('pr_merged_metrics.md')) {
+		console.log('📄 Found pr_merged_metrics.md, parsing...');
+		const prMergedContent = readFileSync('pr_merged_metrics.md', 'utf8');
+
+		metrics.prs_merged = parseCountMetric(
+			prMergedContent,
+			'Total number of items created'
+		);
+		// For merged PRs, "Time to close" is actually time to merge
+		metrics.pr_avg_merge_time = parseMetricsTable(
+			prMergedContent,
+			'Time to close'
+		);
+	} else {
+		console.warn(
+			'[parse-metrics] pr_merged_metrics.md not found; falling back to pr_metrics.md.'
+		);
+		// Fallback: try old pr_metrics.md if it exists
+		if (existsSync('pr_metrics.md')) {
+			console.log('📄 Falling back to pr_metrics.md...');
+			const prContent = readFileSync('pr_metrics.md', 'utf8');
+
+			const mergedCount = parseCountMetric(prContent, 'Number of items merged');
+			metrics.prs_merged =
+				mergedCount || parseCountMetric(prContent, 'Number of items closed');
+
+			const maybeMergeTime = parseMetricsTable(
+				prContent,
+				'Average time to merge'
+			);
+			metrics.pr_avg_merge_time =
+				maybeMergeTime !== 'N/A'
+					? maybeMergeTime
+					: parseMetricsTable(prContent, 'Time to close');
+		} else {
+			console.warn('[parse-metrics] pr_metrics.md not found; using defaults.');
+		}
+	}
+
+	// Output for GitHub Actions
+	const output = Object.entries(metrics)
+		.map(([key, value]) => `${key}=${value}`)
+		.join('\n');
+
+	// Always output to stdout for debugging
+	console.log('\n=== FINAL METRICS ===');
+	Object.entries(metrics).forEach(([key, value]) => {
+		console.log(`${key}: ${value}`);
+	});
+
+	// Write to GITHUB_OUTPUT if in GitHub Actions
+	if (process.env.GITHUB_OUTPUT) {
+		try {
+			writeFileSync(process.env.GITHUB_OUTPUT, output + '\n', { flag: 'a' });
+			console.log(
+				`\nSuccessfully wrote metrics to ${process.env.GITHUB_OUTPUT}`
+			);
+		} catch (error) {
+			console.error(`Failed to write to GITHUB_OUTPUT: ${error.message}`);
+			process.exit(1);
+		}
+	} else {
+		console.log(
+			'\nNo GITHUB_OUTPUT environment variable found, skipping file write'
+		);
+	}
+}
+
+main();

.github/workflows/weekly-metrics-discord.yml

@@ -8,7 +8,7 @@ on:
 
 permissions:
   contents: read
-  issues: write
+  issues: read
   pull-requests: read
 
 jobs:
@@ -17,15 +17,25 @@ jobs:
     env:
       DISCORD_WEBHOOK: ${{ secrets.DISCORD_METRICS_WEBHOOK }}
     steps:
-      - name: Get dates for last week
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Get dates for last 14 days
         run: |
-          # Last 7 days
-          first_day=$(date -d "7 days ago" +%Y-%m-%d)
+          set -Eeuo pipefail
+          # Last 14 days
+          first_day=$(date -d "14 days ago" +%Y-%m-%d)
           last_day=$(date +%Y-%m-%d)
 
           echo "first_day=$first_day" >> $GITHUB_ENV
           echo "last_day=$last_day" >> $GITHUB_ENV
           echo "week_of=$(date -d '7 days ago' +'Week of %B %d, %Y')" >> $GITHUB_ENV
+          echo "date_range=Past 14 days ($first_day to $last_day)" >> $GITHUB_ENV
 
       - name: Generate issue metrics
         uses: github/issue-metrics@v3
@@ -34,40 +44,39 @@ jobs:
           SEARCH_QUERY: "repo:${{ github.repository }} is:issue created:${{ env.first_day }}..${{ env.last_day }}"
           HIDE_TIME_TO_ANSWER: true
           HIDE_LABEL_METRICS: false
+          OUTPUT_FILE: issue_metrics.md
 
-      - name: Generate PR metrics
+      - name: Generate PR created metrics
         uses: github/issue-metrics@v3
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SEARCH_QUERY: "repo:${{ github.repository }} is:pr created:${{ env.first_day }}..${{ env.last_day }}"
-          OUTPUT_FILE: pr_metrics.md
+          OUTPUT_FILE: pr_created_metrics.md
+
+      - name: Generate PR merged metrics
+        uses: github/issue-metrics@v3
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SEARCH_QUERY: "repo:${{ github.repository }} is:pr is:merged merged:${{ env.first_day }}..${{ env.last_day }}"
+          OUTPUT_FILE: pr_merged_metrics.md
+
+      - name: Debug generated metrics
+        run: |
+          set -Eeuo pipefail
+          echo "Listing markdown files in workspace:"
+          ls -la *.md || true
+          for f in issue_metrics.md pr_created_metrics.md pr_merged_metrics.md; do
+            if [ -f "$f" ]; then
+              echo "== $f (first 10 lines) =="
+              head -n 10 "$f"
+            else
+              echo "Missing $f"
+            fi
+          done
 
       - name: Parse metrics
         id: metrics
-        run: |
-          # Parse the metrics from the generated markdown files
-          if [ -f "issue_metrics.md" ]; then
-            # Extract key metrics using grep/awk
-            AVG_TIME_TO_FIRST_RESPONSE=$(grep -A 1 "Average time to first response" issue_metrics.md | tail -1 | xargs || echo "N/A")
-            AVG_TIME_TO_CLOSE=$(grep -A 1 "Average time to close" issue_metrics.md | tail -1 | xargs || echo "N/A")
-            NUM_ISSUES_CREATED=$(grep -oP '\d+(?= issues created)' issue_metrics.md || echo "0")
-            NUM_ISSUES_CLOSED=$(grep -oP '\d+(?= issues closed)' issue_metrics.md || echo "0")
-          fi
-
-          if [ -f "pr_metrics.md" ]; then
-            PR_AVG_TIME_TO_MERGE=$(grep -A 1 "Average time to close" pr_metrics.md | tail -1 | xargs || echo "N/A")
-            NUM_PRS_CREATED=$(grep -oP '\d+(?= pull requests created)' pr_metrics.md || echo "0")
-            NUM_PRS_MERGED=$(grep -oP '\d+(?= pull requests closed)' pr_metrics.md || echo "0")
-          fi
-
-          # Set outputs for Discord action
-          echo "issues_created=${NUM_ISSUES_CREATED:-0}" >> $GITHUB_OUTPUT
-          echo "issues_closed=${NUM_ISSUES_CLOSED:-0}" >> $GITHUB_OUTPUT
-          echo "prs_created=${NUM_PRS_CREATED:-0}" >> $GITHUB_OUTPUT
-          echo "prs_merged=${NUM_PRS_MERGED:-0}" >> $GITHUB_OUTPUT
-          echo "avg_first_response=${AVG_TIME_TO_FIRST_RESPONSE:-N/A}" >> $GITHUB_OUTPUT
-          echo "avg_time_to_close=${AVG_TIME_TO_CLOSE:-N/A}" >> $GITHUB_OUTPUT
-          echo "pr_avg_merge_time=${PR_AVG_TIME_TO_MERGE:-N/A}" >> $GITHUB_OUTPUT
+        run: node .github/scripts/parse-metrics.mjs
 
       - name: Send to Discord
         uses: sarisia/actions-status-discord@v1
@@ -78,19 +87,22 @@ jobs:
           title: "📊 Weekly Metrics Report"
           description: |
             **${{ env.week_of }}**
-            
+            *${{ env.date_range }}*
+
             **🎯 Issues**
             • Created: ${{ steps.metrics.outputs.issues_created }}
             • Closed: ${{ steps.metrics.outputs.issues_closed }}
-            
+            • Avg Response Time: ${{ steps.metrics.outputs.issue_avg_first_response }}
+            • Avg Time to Close: ${{ steps.metrics.outputs.issue_avg_time_to_close }}
+
             **🔀 Pull Requests**
             • Created: ${{ steps.metrics.outputs.prs_created }}
             • Merged: ${{ steps.metrics.outputs.prs_merged }}
-            
-            **⏱️ Response Times**
-            • First Response: ${{ steps.metrics.outputs.avg_first_response }}
-            • Time to Close: ${{ steps.metrics.outputs.avg_time_to_close }}
-            • PR Merge Time: ${{ steps.metrics.outputs.pr_avg_merge_time }}
+            • Avg Response Time: ${{ steps.metrics.outputs.pr_avg_first_response }}
+            • Avg Time to Merge: ${{ steps.metrics.outputs.pr_avg_merge_time }}
+
+            **📈 Visual Analytics**
+            https://repobeats.axiom.co/api/embed/b439f28f0ab5bd7a2da19505355693cd2c55bfd4.svg
           color: 0x58AFFF
           username: Task Master Metrics Bot
           avatar_url: https://raw.githubusercontent.com/eyaltoledano/claude-task-master/main/images/logo.png

.kiro/settings/mcp.json

@@ -2,7 +2,7 @@
 	"mcpServers": {
 		"task-master-ai": {
 			"command": "npx",
-			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
+			"args": ["-y", "task-master-ai"],
 			"env": {
 				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
 				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",

.manypkg.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "https://unpkg.com/@manypkg/get-packages@1.1.3/schema.json",
+	"defaultBranch": "main",
+	"ignoredRules": ["ROOT_HAS_DEPENDENCIES", "INTERNAL_MISMATCH"],
+	"ignoredPackages": ["@tm/core", "@tm/cli", "@tm/build-config"]
+}

.taskmaster/CLAUDE.md

@@ -85,7 +85,7 @@ Task Master provides an MCP server that Claude Code can connect to. Configure in
   "mcpServers": {
     "task-master-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
         "ANTHROPIC_API_KEY": "your_key_here",
         "PERPLEXITY_API_KEY": "your_key_here",
@@ -102,6 +102,35 @@ Task Master provides an MCP server that Claude Code can connect to. Configure in
 }
 ```
 
+For Windows users without WSL, use this configuration instead:
+
+```json
+{
+  "mcpServers": {
+    "task-master-ai": {
+      "command": "cmd",
+      "args": ["/c", "npx -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"
+      }
+    }
+  }
+}
+```
+
+Or install at the project level with Claude Code:
+```bash
+claude mcp add task-master-mcp -s project -- cmd /c "npx -y --package=task-master-ai task-master-ai"
+```
+
 ### Essential MCP Tools
 
 ```javascript

.taskmaster/config.json

@@ -2,8 +2,8 @@
 	"models": {
 		"main": {
 			"provider": "anthropic",
-			"modelId": "claude-3-7-sonnet-20250219",
-			"maxTokens": 120000,
+			"modelId": "claude-sonnet-4-20250514",
+			"maxTokens": 64000,
 			"temperature": 0.2
 		},
 		"research": {
@@ -14,8 +14,8 @@
 		},
 		"fallback": {
 			"provider": "anthropic",
-			"modelId": "claude-3-5-sonnet-20241022",
-			"maxTokens": 8192,
+			"modelId": "claude-3-7-sonnet-20250219",
+			"maxTokens": 120000,
 			"temperature": 0.2
 		}
 	},
@@ -29,9 +29,15 @@
 		"ollamaBaseURL": "http://localhost:11434/api",
 		"bedrockBaseURL": "https://bedrock.us-east-1.amazonaws.com",
 		"responseLanguage": "English",
+		"enableCodebaseAnalysis": true,
 		"userId": "1234567890",
 		"azureBaseURL": "https://your-endpoint.azure.com/",
 		"defaultTag": "master"
 	},
-	"claudeCode": {}
+	"claudeCode": {},
+	"grokCli": {
+		"timeout": 120000,
+		"workingDirectory": null,
+		"defaultModel": "grok-4-latest"
+	}
 }

.taskmaster/docs/prd-tm-start.txt

@@ -0,0 +1,91 @@
+<context>
+# Overview
+Add a new CLI command: `task-master start <task_id>` (alias: `tm start <task_id>`). This command hard-codes `claude-code` as the executor, fetches task details, builds a standardized prompt, runs claude-code, shows the result, checks for git changes, and auto-marks the task as done if successful.
+
+We follow the Commander class pattern, reuse task retrieval from `show` command flow. Extremely minimal for 1-hour hackathon timeline.
+
+# Core Features
+- `start` command (Commander class style) 
+- Hard-coded executor: `claude-code`
+- Standardized prompt designed for minimal changes following existing patterns
+- Shows claude-code output (no streaming)
+- Git status check for success detection
+- Auto-mark task done if successful
+
+# User Experience
+```
+task-master start 12
+```
+1) Fetches Task #12 details
+2) Builds standardized prompt with task context
+3) Runs claude-code with the prompt
+4) Shows output
+5) Checks git status for changes
+6) Auto-marks task done if changes detected
+</context>
+
+<PRD>
+# Technical Architecture
+
+- Command pattern:
+  - Create `apps/cli/src/commands/start.command.ts` modeled on [list.command.ts](mdc:apps/cli/src/commands/list.command.ts) and task lookup from [show.command.ts](mdc:apps/cli/src/commands/show.command.ts)
+
+- Task retrieval:
+  - Use `@tm/core` via `createTaskMasterCore` to get task by ID
+  - Extract: id, title, description, details
+
+- Executor (ultra-simple approach):
+  - Execute `claude "full prompt here"` command directly
+  - The prompt tells Claude to first run `tm show <task_id>` to get task details
+  - Then tells Claude to implement the code changes
+  - This opens Claude CLI interface naturally in the current terminal
+  - No subprocess management needed - just execute the command
+
+- Execution flow:
+  1) Validate `<task_id>` exists; exit with error if not
+  2) Build standardized prompt that includes instructions to run `tm show <task_id>`
+  3) Execute `claude "prompt"` command directly in terminal
+  4) Claude CLI opens, runs `tm show`, then implements changes
+  5) After Claude session ends, run `git status --porcelain` to detect changes
+  6) If changes detected, auto-run `task-master set-status --id=<task_id> --status=done`
+
+- Success criteria:
+  - Success = exit code 0 AND git shows modified/created files
+  - Print changed file paths; warn if no changes detected
+
+# Development Roadmap
+
+MVP (ship in ~1 hour):
+1) Implement `start.command.ts` (Commander class), parse `<task_id>`
+2) Validate task exists via tm-core 
+3) Build prompt that tells Claude to run `tm show <task_id>` then implement
+4) Execute `claude "prompt"` command, then check git status and auto-mark done
+
+# Risks and Mitigations
+- Executor availability: Error clearly if `claude-code` provider fails
+- False success: Git-change heuristic acceptable for hackathon MVP
+
+# Appendix
+
+**Standardized Prompt Template:**
+```
+You are an AI coding assistant with access to this repository's codebase.
+
+First, run this command to get the task details:
+tm show <task_id>
+
+Then implement the task with these requirements:
+- Make the SMALLEST number of code changes possible
+- Follow ALL existing patterns in the codebase (you have access to analyze the code)
+- Do NOT over-engineer the solution
+- Use existing files/functions/patterns wherever possible
+- When complete, print: COMPLETED: <brief summary of changes>
+
+Begin by running tm show <task_id> to understand what needs to be implemented.
+```
+
+**Key References:**
+- [list.command.ts](mdc:apps/cli/src/commands/list.command.ts) - Command structure
+- [show.command.ts](mdc:apps/cli/src/commands/show.command.ts) - Task validation
+- Node.js `child_process.exec()` - For executing `claude "prompt"` command
+</PRD>

.taskmaster/state.json

@@ -1,6 +1,6 @@
 {
 	"currentTag": "master",
-	"lastSwitched": "2025-08-27T21:03:20.550Z",
+	"lastSwitched": "2025-09-12T22:25:27.535Z",
 	"branchTagMapping": {
 		"v017-adds": "v017-adds",
 		"next": "next"

.taskmaster/tasks/task_001_tm-start.txt

@@ -0,0 +1,34 @@
+# Task ID: 1
+# Title: Create start command class structure
+# Status: pending
+# Dependencies: None
+# Priority: high
+# Description: Create the basic structure for the start command following the Commander class pattern
+# Details:
+Create a new file `apps/cli/src/commands/start.command.ts` based on the existing list.command.ts pattern. Implement the command class with proper command registration, description, and argument handling for the task_id parameter. The class should extend the base Command class and implement the required methods.
+
+Example structure:
+```typescript
+import { Command } from 'commander';
+import { BaseCommand } from './base.command';
+
+export class StartCommand extends BaseCommand {
+  public register(program: Command): void {
+    program
+      .command('start')
+      .alias('tm start')
+      .description('Start implementing a task using claude-code')
+      .argument('<task_id>', 'ID of the task to start')
+      .action(async (taskId: string) => {
+        await this.execute(taskId);
+      });
+  }
+
+  public async execute(taskId: string): Promise<void> {
+    // Implementation will be added in subsequent tasks
+  }
+}
+```
+
+# Test Strategy:
+Verify the command registers correctly by running the CLI with --help and checking that the start command appears with proper description and arguments. Test the basic structure by ensuring the command can be invoked without errors.

.taskmaster/tasks/task_002_tm-start.txt

@@ -0,0 +1,26 @@
+# Task ID: 2
+# Title: Register start command in CLI
+# Status: pending
+# Dependencies: 7
+# Priority: high
+# Description: Register the start command in the CLI application
+# Details:
+Update the CLI application to register the new start command. This involves importing the StartCommand class and adding it to the commands array in the CLI initialization.
+
+In `apps/cli/src/index.ts` or the appropriate file where commands are registered:
+
+```typescript
+import { StartCommand } from './commands/start.command';
+
+// Add StartCommand to the commands array
+const commands = [
+  // ... existing commands
+  new StartCommand(),
+];
+
+// Register all commands
+commands.forEach(command => command.register(program));
+```
+
+# Test Strategy:
+Verify the command is correctly registered by running the CLI with --help and checking that the start command appears in the list of available commands.

.taskmaster/tasks/task_003_tm-start.txt

@@ -0,0 +1,32 @@
+# Task ID: 3
+# Title: Create standardized prompt builder
+# Status: pending
+# Dependencies: 1
+# Priority: medium
+# Description: Implement a function to build the standardized prompt for claude-code based on the task details
+# Details:
+Create a function in the StartCommand class that builds the standardized prompt according to the template provided in the PRD. The prompt should include instructions for Claude to first run `tm show <task_id>` to get task details, and then implement the required changes.
+
+```typescript
+private buildPrompt(taskId: string): string {
+  return `You are an AI coding assistant with access to this repository's codebase.
+
+First, run this command to get the task details:
+tm show ${taskId}
+
+Then implement the task with these requirements:
+- Make the SMALLEST number of code changes possible
+- Follow ALL existing patterns in the codebase (you have access to analyze the code)
+- Do NOT over-engineer the solution
+- Use existing files/functions/patterns wherever possible
+- When complete, print: COMPLETED: <brief summary of changes>
+
+Begin by running tm show ${taskId} to understand what needs to be implemented.`;
+}
+```
+<info added on 2025-09-12T02:40:01.812Z>
+The prompt builder function will handle task context retrieval by instructing Claude to use the task-master show command. This approach ensures Claude has access to all necessary task details before implementation begins. The command syntax "tm show ${taskId}" embedded in the prompt will direct Claude to first gather the complete task context, including description, requirements, and any existing implementation details, before proceeding with code changes.
+</info added on 2025-09-12T02:40:01.812Z>
+
+# Test Strategy:
+Verify the prompt is correctly formatted by calling the function with a sample task ID and checking that the output matches the expected template with the task ID properly inserted.

.taskmaster/tasks/task_004_tm-start.txt

@@ -0,0 +1,36 @@
+# Task ID: 4
+# Title: Implement claude-code executor
+# Status: pending
+# Dependencies: 3
+# Priority: high
+# Description: Add functionality to execute the claude-code command with the built prompt
+# Details:
+Implement the functionality to execute the claude command with the built prompt. This should use Node.js child_process.exec() to run the command directly in the terminal.
+
+```typescript
+import { exec } from 'child_process';
+
+// Inside execute method, after task validation
+private async executeClaude(prompt: string): Promise<void> {
+  console.log('Starting claude-code to implement the task...');
+  
+  try {
+    // Execute claude with the prompt
+    const claudeCommand = `claude "${prompt.replace(/"/g, '\\"')}"`;
+    
+    // Use execSync to wait for the command to complete
+    const { execSync } = require('child_process');
+    execSync(claudeCommand, { stdio: 'inherit' });
+    
+    console.log('Claude session completed.');
+  } catch (error) {
+    console.error('Error executing claude-code:', error.message);
+    process.exit(1);
+  }
+}
+```
+
+Then call this method from the execute method after building the prompt.
+
+# Test Strategy:
+Test by running the command with a valid task ID and verifying that the claude command is executed with the correct prompt. Check that the command handles errors appropriately if claude-code is not available.

.taskmaster/tasks/task_007_tm-start.txt

@@ -0,0 +1,49 @@
+# Task ID: 7
+# Title: Integrate execution flow in start command
+# Status: pending
+# Dependencies: 3, 4
+# Priority: high
+# Description: Connect all the components to implement the complete execution flow for the start command
+# Details:
+Update the execute method in the StartCommand class to integrate all the components and implement the complete execution flow as described in the PRD:
+1. Validate task exists
+2. Build standardized prompt
+3. Execute claude-code
+4. Check git status for changes
+5. Auto-mark task as done if changes detected
+
+```typescript
+public async execute(taskId: string): Promise<void> {
+  // Validate task exists
+  const core = await createTaskMasterCore();
+  const task = await core.tasks.getById(parseInt(taskId, 10));
+  
+  if (!task) {
+    console.error(`Task with ID ${taskId} not found`);
+    process.exit(1);
+  }
+  
+  // Build prompt
+  const prompt = this.buildPrompt(taskId);
+  
+  // Execute claude-code
+  await this.executeClaude(prompt);
+  
+  // Check git status
+  const changedFiles = await this.checkGitChanges();
+  
+  if (changedFiles.length > 0) {
+    console.log('\nChanges detected in the following files:');
+    changedFiles.forEach(file => console.log(`- ${file}`));
+    
+    // Auto-mark task as done
+    await this.markTaskAsDone(taskId);
+    console.log(`\nTask ${taskId} completed successfully and marked as done.`);
+  } else {
+    console.warn('\nNo changes detected after claude-code execution. Task not marked as done.');
+  }
+}
+```
+
+# Test Strategy:
+Test the complete execution flow by running the start command with a valid task ID and verifying that all steps are executed correctly. Test with both scenarios: when changes are detected and when no changes are detected.

CHANGELOG.md

@@ -1,5 +1,102 @@
 # task-master-ai
 
+## 0.27.3
+
+### Patch Changes
+
+- [#1254](https://github.com/eyaltoledano/claude-task-master/pull/1254) [`af53525`](https://github.com/eyaltoledano/claude-task-master/commit/af53525cbc660a595b67d4bb90d906911c71f45d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fixed issue where `tm show` command could not find subtasks using dotted notation IDs (e.g., '8.1').
+  - The command now properly searches within parent task subtasks and returns the correct subtask information.
+
+## 0.27.2
+
+### Patch Changes
+
+- [#1248](https://github.com/eyaltoledano/claude-task-master/pull/1248) [`044a7bf`](https://github.com/eyaltoledano/claude-task-master/commit/044a7bfc98049298177bc655cf341d7a8b6a0011) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix set-status for subtasks:
+  - Parent tasks are now set as `done` when subtasks are all `done`
+  - Parent tasks are now set as `in-progress` when at least one subtask is `in-progress` or `done`
+
+## 0.27.1
+
+### Patch Changes
+
+- [#1232](https://github.com/eyaltoledano/claude-task-master/pull/1232) [`f487736`](https://github.com/eyaltoledano/claude-task-master/commit/f487736670ef8c484059f676293777eabb249c9e) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix module not found for new 0.27.0 release
+
+- [#1233](https://github.com/eyaltoledano/claude-task-master/pull/1233) [`c911608`](https://github.com/eyaltoledano/claude-task-master/commit/c911608f60454253f4e024b57ca84e5a5a53f65c) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix Zed MCP configuration by adding required "source" property
+  - Add "source": "custom" property to task-master-ai server in Zed settings.json
+
+## 0.27.1-rc.1
+
+### Patch Changes
+
+- [#1233](https://github.com/eyaltoledano/claude-task-master/pull/1233) [`1a18794`](https://github.com/eyaltoledano/claude-task-master/commit/1a1879483b86c118a4e46c02cbf4acebfcf6bcf9) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - One last testing final final
+
+## 0.27.1-rc.0
+
+### Patch Changes
+
+- [#1232](https://github.com/eyaltoledano/claude-task-master/pull/1232) [`f487736`](https://github.com/eyaltoledano/claude-task-master/commit/f487736670ef8c484059f676293777eabb249c9e) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix module not found for new 0.27.0 release
+
+## 0.27.0
+
+### Minor Changes
+
+- [#1220](https://github.com/eyaltoledano/claude-task-master/pull/1220) [`4e12643`](https://github.com/eyaltoledano/claude-task-master/commit/4e126430a092fb54afb035514fb3d46115714f97) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - No longer need --package=task-master-ai in mcp server
+  - A lot of users were having issues with Taskmaster and usually a simple fix was to remove --package from your mcp.json
+  - we now bundle our whole package, so we no longer need the --package
+
+- [#1200](https://github.com/eyaltoledano/claude-task-master/pull/1200) [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add new `task-master start` command for automated task execution with Claude Code
+  - You can now start working on tasks directly by running `task-master start <task-id>` which will automatically launch Claude Code with a comprehensive prompt containing all task details, implementation guidelines, and context.
+  - `task-master start` will automatically detect next-task when no ID is provided.
+
+- [#1200](https://github.com/eyaltoledano/claude-task-master/pull/1200) [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Move from javascript to typescript, not a full refactor but we now have a typescript environment and are moving our javascript commands slowly into typescript
+
+- [#1200](https://github.com/eyaltoledano/claude-task-master/pull/1200) [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add grok-cli as a provider with full codebase context support. You can now use Grok models (grok-2, grok-3, grok-4, etc.) with Task Master for AI operations that have access to your entire codebase context, enabling more informed task generation and PRD parsing.
+
+  ## Setup Instructions
+  1. **Get your Grok API key** from [console.x.ai](https://console.x.ai)
+  2. **Set the environment variable**:
+     ```bash
+     export GROK_CLI_API_KEY="your-api-key-here"
+     ```
+  3. **Configure Task Master to use Grok**:
+     ```bash
+     task-master models --set-main grok-beta
+     # or
+     task-master models --set-research grok-beta
+     # or
+     task-master models --set-fallback grok-beta
+     ```
+
+  ## Key Features
+  - **Full codebase context**: Grok models can analyze your entire project when generating tasks or parsing PRDs
+  - **xAI model access**: Support for latest Grok models (grok-2, grok-3, grok-4, etc.)
+  - **Code-aware task generation**: Create more accurate and contextual tasks based on your actual codebase
+  - **Intelligent PRD parsing**: Parse requirements with understanding of your existing code structure
+
+  ## Available Models
+  - `grok-beta` - Latest Grok model with codebase context
+  - `grok-vision-beta` - Grok with vision capabilities and codebase context
+
+  The Grok CLI provider integrates with xAI's Grok models via grok-cli and can also use the local Grok CLI configuration file (`~/.grok/user-settings.json`) if available.
+
+  ## Credits
+
+  Built using the [grok-cli](https://github.com/superagent-ai/grok-cli) by Superagent AI for seamless integration with xAI's Grok models.
+
+- [#1225](https://github.com/eyaltoledano/claude-task-master/pull/1225) [`a621ff0`](https://github.com/eyaltoledano/claude-task-master/commit/a621ff05eafb51a147a9aabd7b37ddc0e45b0869) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve taskmaster ai provider defaults
+  - moving from main anthropic 3.7 to anthropic sonnet 4
+  - moving from fallback anthropic 3.5 to anthropic 3.7
+
+- [#1217](https://github.com/eyaltoledano/claude-task-master/pull/1217) [`e6de285`](https://github.com/eyaltoledano/claude-task-master/commit/e6de285ceacb0a397e952a63435cd32a9c731515) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - @tm/cli: add auto-update functionality to every command
+
+- [#1200](https://github.com/eyaltoledano/claude-task-master/pull/1200) [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fix Grok model configuration validation and update deprecated Claude fallback model. Grok models now properly support their full 131K token capacity, and the fallback model has been upgraded to Claude Sonnet 4 for better performance and future compatibility.
+
+## 0.27.0-rc.2
+
+### Minor Changes
+
+- [#1217](https://github.com/eyaltoledano/claude-task-master/pull/1217) [`e6de285`](https://github.com/eyaltoledano/claude-task-master/commit/e6de285ceacb0a397e952a63435cd32a9c731515) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - @tm/cli: add auto-update functionality to every command
+
 ## 0.27.0-rc.1
 
 ### Minor Changes

README.md

@@ -102,7 +102,7 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
   "mcpServers": {
     "task-master-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
@@ -122,7 +122,8 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
 
 > 🔑 Replace `YOUR_…_KEY_HERE` with your real API keys. You can remove keys you don't use.
 
-> **Note**: If you see `0 tools enabled` in the MCP settings, try removing the `--package=task-master-ai` flag from `args`.
+> **Note**: If you see `0 tools enabled` in the MCP settings, restart your editor and check that your API keys are correctly configured.
+
 
 ###### VS Code (`servers` + `type`)
 
@@ -131,7 +132,7 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
   "servers": {
     "task-master-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",

apps/cli/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @tm/cli
 
+## null
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tm/core@null
+
+## 0.27.0
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tm/core@0.26.1
+
 ## 0.27.0-rc.0
 
 ### Minor Changes

apps/cli/package.json

@@ -1,6 +1,5 @@
 {
 	"name": "@tm/cli",
-	"version": "0.27.0-rc.0",
 	"description": "Task Master CLI - Command line interface for task management",
 	"type": "module",
 	"private": true,
@@ -24,12 +23,12 @@
 	},
 	"dependencies": {
 		"@tm/core": "*",
-		"boxen": "^7.1.1",
+		"boxen": "^8.0.1",
 		"chalk": "5.6.2",
 		"cli-table3": "^0.6.5",
 		"commander": "^12.1.0",
-		"inquirer": "^9.2.10",
-		"ora": "^8.1.0"
+		"inquirer": "^12.5.0",
+		"ora": "^8.2.0"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.4",

apps/cli/src/commands/context.command.ts

@@ -6,7 +6,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import ora from 'ora';
+import ora, { Ora } from 'ora';
 import {
 	AuthManager,
 	AuthenticationError,
@@ -49,8 +49,15 @@ export class ContextCommand extends Command {
 		this.addClearCommand();
 		this.addSetCommand();
 
-		// Default action shows current context
-		this.action(async () => {
+		// Accept optional positional argument for brief ID or Hamster URL
+		this.argument('[briefOrUrl]', 'Brief ID or Hamster brief URL');
+
+		// Default action: if an argument is provided, resolve and set context; else show
+		this.action(async (briefOrUrl?: string) => {
+			if (briefOrUrl && briefOrUrl.trim().length > 0) {
+				await this.executeSetFromBriefInput(briefOrUrl.trim());
+				return;
+			}
 			await this.executeShow();
 		});
 	}
@@ -441,6 +448,142 @@ export class ContextCommand extends Command {
 		}
 	}
 
+	/**
+	 * Execute setting context from a brief ID or Hamster URL
+	 */
+	private async executeSetFromBriefInput(briefOrUrl: string): Promise<void> {
+		let spinner: Ora | undefined;
+		try {
+			// Check authentication
+			if (!this.authManager.isAuthenticated()) {
+				ui.displayError('Not authenticated. Run "tm auth login" first.');
+				process.exit(1);
+			}
+
+			spinner = ora('Resolving brief...');
+			spinner.start();
+
+			// Extract brief ID
+			const briefId = this.extractBriefId(briefOrUrl);
+			if (!briefId) {
+				spinner.fail('Could not extract a brief ID from the provided input');
+				ui.displayError(
+					`Provide a valid brief ID or a Hamster brief URL, e.g. https://${process.env.TM_PUBLIC_BASE_DOMAIN}/home/hamster/briefs/<id>`
+				);
+				process.exit(1);
+			}
+
+			// Fetch brief and resolve its organization
+			const brief = await this.authManager.getBrief(briefId);
+			if (!brief) {
+				spinner.fail('Brief not found or you do not have access');
+				process.exit(1);
+			}
+
+			// Fetch org to get a friendly name (optional)
+			let orgName: string | undefined;
+			try {
+				const org = await this.authManager.getOrganization(brief.accountId);
+				orgName = org?.name;
+			} catch {
+				// Non-fatal if org lookup fails
+			}
+
+			// Update context: set org and brief
+			const briefName = `Brief ${brief.id.slice(0, 8)}`;
+			await this.authManager.updateContext({
+				orgId: brief.accountId,
+				orgName,
+				briefId: brief.id,
+				briefName
+			});
+
+			spinner.succeed('Context set from brief');
+			console.log(
+				chalk.gray(
+					`  Organization: ${orgName || brief.accountId}\n  Brief: ${briefName}`
+				)
+			);
+
+			this.setLastResult({
+				success: true,
+				action: 'set',
+				context: this.authManager.getContext() || undefined,
+				message: 'Context set from brief'
+			});
+		} catch (error: any) {
+			try {
+				if (spinner?.isSpinning) spinner.stop();
+			} catch {}
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Extract a brief ID from raw input (ID or Hamster URL)
+	 */
+	private extractBriefId(input: string): string | null {
+		const raw = input?.trim() ?? '';
+		if (!raw) return null;
+
+		const parseUrl = (s: string): URL | null => {
+			try {
+				return new URL(s);
+			} catch {}
+			try {
+				return new URL(`https://${s}`);
+			} catch {}
+			return null;
+		};
+
+		const fromParts = (path: string): string | null => {
+			const parts = path.split('/').filter(Boolean);
+			const briefsIdx = parts.lastIndexOf('briefs');
+			const candidate =
+				briefsIdx >= 0 && parts.length > briefsIdx + 1
+					? parts[briefsIdx + 1]
+					: parts[parts.length - 1];
+			return candidate?.trim() || null;
+		};
+
+		// 1) URL (absolute or scheme‑less)
+		const url = parseUrl(raw);
+		if (url) {
+			const qId = url.searchParams.get('id') || url.searchParams.get('briefId');
+			const candidate = (qId || fromParts(url.pathname)) ?? null;
+			if (candidate) {
+				// Light sanity check; let API be the final validator
+				if (this.isLikelyId(candidate) || candidate.length >= 8)
+					return candidate;
+			}
+		}
+
+		// 2) Looks like a path without scheme
+		if (raw.includes('/')) {
+			const candidate = fromParts(raw);
+			if (candidate && (this.isLikelyId(candidate) || candidate.length >= 8)) {
+				return candidate;
+			}
+		}
+
+		// 3) Fallback: raw token
+		return raw;
+	}
+
+	/**
+	 * Heuristic to check if a string looks like a brief ID (UUID-like)
+	 */
+	private isLikelyId(value: string): boolean {
+		const uuidRegex =
+			/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+		const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i; // ULID
+		const slugRegex = /^[A-Za-z0-9_-]{16,}$/; // general token
+		return (
+			uuidRegex.test(value) || ulidRegex.test(value) || slugRegex.test(value)
+		);
+	}
+
 	/**
 	 * Set context directly from options
 	 */

apps/cli/src/commands/show.command.ts

@@ -9,14 +9,7 @@ import boxen from 'boxen';
 import { createTaskMasterCore, type Task, type TaskMasterCore } from '@tm/core';
 import type { StorageType } from '@tm/core/types';
 import * as ui from '../utils/ui.js';
-import {
-	displayTaskHeader,
-	displayTaskProperties,
-	displayImplementationDetails,
-	displayTestStrategy,
-	displaySubtasks,
-	displaySuggestedActions
-} from '../ui/components/task-detail.component.js';
+import { displayTaskDetails } from '../ui/components/task-detail.component.js';
 
 /**
  * Options interface for the show command
@@ -264,44 +257,11 @@ export class ShowCommand extends Command {
 			return;
 		}
 
-		const task = result.task;
-
-		// Display header with tag
-		displayTaskHeader(task.id, task.title);
-
-		// Display task properties in table format
-		displayTaskProperties(task);
-
-		// Display implementation details if available
-		if (task.details) {
-			console.log(); // Empty line for spacing
-			displayImplementationDetails(task.details);
-		}
-
-		// Display test strategy if available
-		if ('testStrategy' in task && task.testStrategy) {
-			console.log(); // Empty line for spacing
-			displayTestStrategy(task.testStrategy as string);
-		}
-
-		// Display subtasks if available
-		if (task.subtasks && task.subtasks.length > 0) {
-			// Filter subtasks by status if provided
-			const filteredSubtasks = options.status
-				? task.subtasks.filter((sub) => sub.status === options.status)
-				: task.subtasks;
-
-			if (filteredSubtasks.length === 0 && options.status) {
-				console.log(
-					chalk.gray(`  No subtasks with status '${options.status}'`)
-				);
-			} else {
-				displaySubtasks(filteredSubtasks, task.id);
-			}
-		}
-
-		// Display suggested actions
-		displaySuggestedActions(task.id);
+		// Use the global task details display function
+		displayTaskDetails(result.task, {
+			statusFilter: options.status,
+			showSuggestedActions: true
+		});
 	}
 
 	/**

apps/cli/src/commands/start.command.ts

@@ -0,0 +1,512 @@
+/**
+ * @fileoverview StartCommand using Commander's native class pattern
+ * Extends Commander.Command for better integration with the framework
+ * This is a thin presentation layer over @tm/core's TaskExecutionService
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import ora, { type Ora } from 'ora';
+import { spawn } from 'child_process';
+import {
+	createTaskMasterCore,
+	type TaskMasterCore,
+	type StartTaskResult as CoreStartTaskResult
+} from '@tm/core';
+import { displayTaskDetails } from '../ui/components/task-detail.component.js';
+import * as ui from '../utils/ui.js';
+
+/**
+ * CLI-specific options interface for the start command
+ */
+export interface StartCommandOptions {
+	id?: string;
+	format?: 'text' | 'json';
+	project?: string;
+	dryRun?: boolean;
+	force?: boolean;
+	noStatusUpdate?: boolean;
+}
+
+/**
+ * CLI-specific result type from start command
+ * Extends the core result with CLI-specific display information
+ */
+export interface StartCommandResult extends CoreStartTaskResult {
+	storageType?: string;
+}
+
+/**
+ * StartCommand extending Commander's Command class
+ * This is a thin presentation layer over @tm/core's TaskExecutionService
+ */
+export class StartCommand extends Command {
+	private tmCore?: TaskMasterCore;
+	private lastResult?: StartCommandResult;
+
+	constructor(name?: string) {
+		super(name || 'start');
+
+		// Configure the command
+		this.description(
+			'Start working on a task by launching claude-code with context'
+		)
+			.argument('[id]', 'Task ID to start working on')
+			.option('-i, --id <id>', 'Task ID to start working on')
+			.option('-f, --format <format>', 'Output format (text, json)', 'text')
+			.option('-p, --project <path>', 'Project root directory', process.cwd())
+			.option(
+				'--dry-run',
+				'Show what would be executed without launching claude-code'
+			)
+			.option(
+				'--force',
+				'Force start even if another task is already in-progress'
+			)
+			.option(
+				'--no-status-update',
+				'Do not automatically update task status to in-progress'
+			)
+			.action(
+				async (taskId: string | undefined, options: StartCommandOptions) => {
+					await this.executeCommand(taskId, options);
+				}
+			);
+	}
+
+	/**
+	 * Execute the start command
+	 */
+	private async executeCommand(
+		taskId: string | undefined,
+		options: StartCommandOptions
+	): Promise<void> {
+		let spinner: Ora | null = null;
+
+		try {
+			// Validate options
+			if (!this.validateOptions(options)) {
+				process.exit(1);
+			}
+
+			// Initialize tm-core with spinner
+			spinner = ora('Initializing Task Master...').start();
+			await this.initializeCore(options.project || process.cwd());
+			spinner.succeed('Task Master initialized');
+
+			// Get the task ID from argument or option, or find next available task
+			const idArg = taskId || options.id || null;
+			let targetTaskId = idArg;
+
+			if (!targetTaskId) {
+				spinner = ora('Finding next available task...').start();
+				targetTaskId = await this.performGetNextTask();
+				if (targetTaskId) {
+					spinner.succeed(`Found next task: #${targetTaskId}`);
+				} else {
+					spinner.fail('No available tasks found');
+				}
+			}
+
+			if (!targetTaskId) {
+				ui.displayError('No task ID provided and no available tasks found');
+				process.exit(1);
+			}
+
+			// Show pre-launch message (no spinner needed, it's just display)
+			if (!options.dryRun) {
+				await this.showPreLaunchMessage(targetTaskId);
+			}
+
+			// Use tm-core's startTask method with spinner
+			spinner = ora('Preparing task execution...').start();
+			const coreResult = await this.performStartTask(targetTaskId, options);
+
+			if (coreResult.started) {
+				spinner.succeed(
+					options.dryRun
+						? 'Dry run completed'
+						: 'Task prepared - launching Claude...'
+				);
+			} else {
+				spinner.fail('Task execution failed');
+			}
+
+			// Execute command if we have one and it's not a dry run
+			if (!options.dryRun && coreResult.command) {
+				// Stop any remaining spinners before launching Claude
+				if (spinner && !spinner.isSpinning) {
+					// Clear the line to make room for Claude
+					console.log();
+				}
+				await this.executeChildProcess(coreResult.command);
+			}
+
+			// Convert core result to CLI result with storage type
+			const result: StartCommandResult = {
+				...coreResult,
+				storageType: this.tmCore?.getStorageType()
+			};
+
+			// Store result for programmatic access
+			this.setLastResult(result);
+
+			// Display results (only for dry run or if execution failed)
+			if (options.dryRun || !coreResult.started) {
+				this.displayResults(result, options);
+			}
+		} catch (error: any) {
+			if (spinner) {
+				spinner.fail('Operation failed');
+			}
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Validate command options
+	 */
+	private validateOptions(options: StartCommandOptions): boolean {
+		// Validate format
+		if (options.format && !['text', 'json'].includes(options.format)) {
+			console.error(chalk.red(`Invalid format: ${options.format}`));
+			console.error(chalk.gray(`Valid formats: text, json`));
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Initialize TaskMasterCore
+	 */
+	private async initializeCore(projectRoot: string): Promise<void> {
+		if (!this.tmCore) {
+			this.tmCore = await createTaskMasterCore({ projectPath: projectRoot });
+		}
+	}
+
+	/**
+	 * Get the next available task using tm-core
+	 */
+	private async performGetNextTask(): Promise<string | null> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+		return this.tmCore.getNextAvailableTask();
+	}
+
+	/**
+	 * Show pre-launch message using tm-core data
+	 */
+	private async showPreLaunchMessage(targetTaskId: string): Promise<void> {
+		if (!this.tmCore) return;
+
+		const { task, subtask, subtaskId } =
+			await this.tmCore.getTaskWithSubtask(targetTaskId);
+		if (task) {
+			const workItemText = subtask
+				? `Subtask #${task.id}.${subtaskId} - ${subtask.title}`
+				: `Task #${task.id} - ${task.title}`;
+
+			console.log(
+				chalk.green('🚀 Starting: ') + chalk.white.bold(workItemText)
+			);
+			console.log(chalk.gray('Launching Claude Code...'));
+			console.log(); // Empty line
+		}
+	}
+
+	/**
+	 * Perform start task using tm-core business logic
+	 */
+	private async performStartTask(
+		targetTaskId: string,
+		options: StartCommandOptions
+	): Promise<CoreStartTaskResult> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+
+		// Show spinner for status update if enabled
+		let statusSpinner: Ora | null = null;
+		if (!options.noStatusUpdate && !options.dryRun) {
+			statusSpinner = ora('Updating task status to in-progress...').start();
+		}
+
+		// Get execution command from tm-core (instead of executing directly)
+		const result = await this.tmCore.startTask(targetTaskId, {
+			dryRun: options.dryRun,
+			force: options.force,
+			updateStatus: !options.noStatusUpdate
+		});
+
+		if (statusSpinner) {
+			if (result.started) {
+				statusSpinner.succeed('Task status updated');
+			} else {
+				statusSpinner.warn('Task status update skipped');
+			}
+		}
+
+		if (!result) {
+			throw new Error('Failed to start task - core result is undefined');
+		}
+
+		// Don't execute here - let the main executeCommand method handle it
+		return result;
+	}
+
+	/**
+	 * Execute the child process directly in the main thread for better process control
+	 */
+	private async executeChildProcess(command: {
+		executable: string;
+		args: string[];
+		cwd: string;
+	}): Promise<void> {
+		return new Promise((resolve, reject) => {
+			// Don't show the full command with args as it can be very long
+			console.log(chalk.green('🚀 Launching Claude Code...'));
+			console.log(); // Add space before Claude takes over
+
+			const childProcess = spawn(command.executable, command.args, {
+				cwd: command.cwd,
+				stdio: 'inherit', // Inherit stdio from parent process
+				shell: false
+			});
+
+			childProcess.on('close', (code) => {
+				if (code === 0) {
+					resolve();
+				} else {
+					reject(new Error(`Process exited with code ${code}`));
+				}
+			});
+
+			childProcess.on('error', (error) => {
+				reject(new Error(`Failed to spawn process: ${error.message}`));
+			});
+
+			// Handle process termination signals gracefully
+			const cleanup = () => {
+				if (childProcess && !childProcess.killed) {
+					childProcess.kill('SIGTERM');
+				}
+			};
+
+			process.on('SIGINT', cleanup);
+			process.on('SIGTERM', cleanup);
+			process.on('exit', cleanup);
+		});
+	}
+
+	/**
+	 * Display results based on format
+	 */
+	private displayResults(
+		result: StartCommandResult,
+		options: StartCommandOptions
+	): void {
+		const format = options.format || 'text';
+
+		switch (format) {
+			case 'json':
+				this.displayJson(result);
+				break;
+
+			case 'text':
+			default:
+				this.displayTextResult(result, options);
+				break;
+		}
+	}
+
+	/**
+	 * Display in JSON format
+	 */
+	private displayJson(result: StartCommandResult): void {
+		console.log(JSON.stringify(result, null, 2));
+	}
+
+	/**
+	 * Display result in text format
+	 */
+	private displayTextResult(
+		result: StartCommandResult,
+		options: StartCommandOptions
+	): void {
+		if (!result.found || !result.task) {
+			console.log(
+				boxen(chalk.yellow(`Task not found!`), {
+					padding: { top: 0, bottom: 0, left: 1, right: 1 },
+					borderColor: 'yellow',
+					borderStyle: 'round',
+					margin: { top: 1 }
+				})
+			);
+			return;
+		}
+
+		const task = result.task;
+
+		if (options.dryRun) {
+			// For dry run, show full details since Claude Code won't be launched
+			let headerText = `Dry Run: Starting Task #${task.id} - ${task.title}`;
+
+			// If working on a specific subtask, highlight it in the header
+			if (result.subtask && result.subtaskId) {
+				headerText = `Dry Run: Starting Subtask #${task.id}.${result.subtaskId} - ${result.subtask.title}`;
+			}
+
+			displayTaskDetails(task, {
+				customHeader: headerText,
+				headerColor: 'yellow'
+			});
+
+			// Show claude-code prompt
+			if (result.executionOutput) {
+				console.log(); // Empty line for spacing
+				console.log(
+					boxen(
+						chalk.white.bold('Claude-Code Prompt:') +
+							'\n\n' +
+							result.executionOutput,
+						{
+							padding: 1,
+							borderStyle: 'round',
+							borderColor: 'cyan',
+							width: process.stdout.columns * 0.95 || 100
+						}
+					)
+				);
+			}
+
+			console.log(); // Empty line for spacing
+			console.log(
+				boxen(
+					chalk.yellow(
+						'🔍 Dry run - claude-code would be launched with the above prompt'
+					),
+					{
+						padding: { top: 0, bottom: 0, left: 1, right: 1 },
+						borderColor: 'yellow',
+						borderStyle: 'round'
+					}
+				)
+			);
+		} else {
+			// For actual execution, show minimal info since Claude Code will clear the terminal
+			if (result.started) {
+				// Determine what was worked on - task or subtask
+				let workItemText = `Task: #${task.id} - ${task.title}`;
+				let statusTarget = task.id;
+
+				if (result.subtask && result.subtaskId) {
+					workItemText = `Subtask: #${task.id}.${result.subtaskId} - ${result.subtask.title}`;
+					statusTarget = `${task.id}.${result.subtaskId}`;
+				}
+
+				// Post-execution message (shown after Claude Code exits)
+				console.log(
+					boxen(
+						chalk.green.bold('🎉 Task Session Complete!') +
+							'\n\n' +
+							chalk.white(workItemText) +
+							'\n\n' +
+							chalk.cyan('Next steps:') +
+							'\n' +
+							`• Run ${chalk.yellow('tm show ' + task.id)} to review task details\n` +
+							`• Run ${chalk.yellow('tm set-status --id=' + statusTarget + ' --status=done')} when complete\n` +
+							`• Run ${chalk.yellow('tm next')} to find the next available task\n` +
+							`• Run ${chalk.yellow('tm start')} to begin the next task`,
+						{
+							padding: 1,
+							borderStyle: 'round',
+							borderColor: 'green',
+							width: process.stdout.columns * 0.95 || 100,
+							margin: { top: 1 }
+						}
+					)
+				);
+			} else {
+				// Error case
+				console.log(
+					boxen(
+						chalk.red(
+							'❌ Failed to launch claude-code' +
+								(result.error ? `\nError: ${result.error}` : '')
+						),
+						{
+							padding: { top: 0, bottom: 0, left: 1, right: 1 },
+							borderColor: 'red',
+							borderStyle: 'round'
+						}
+					)
+				);
+			}
+		}
+
+		console.log(`\n${chalk.gray('Storage: ' + result.storageType)}`);
+	}
+
+	/**
+	 * Handle general errors
+	 */
+	private handleError(error: any): void {
+		const msg = error?.getSanitizedDetails?.() ?? {
+			message: error?.message ?? String(error)
+		};
+		console.error(chalk.red(`Error: ${msg.message || 'Unexpected error'}`));
+
+		// Show stack trace in development mode or when DEBUG is set
+		const isDevelopment = process.env.NODE_ENV !== 'production';
+		if ((isDevelopment || process.env.DEBUG) && error.stack) {
+			console.error(chalk.gray(error.stack));
+		}
+	}
+
+	/**
+	 * Set the last result for programmatic access
+	 */
+	private setLastResult(result: StartCommandResult): void {
+		this.lastResult = result;
+	}
+
+	/**
+	 * Get the last result (for programmatic usage)
+	 */
+	getLastResult(): StartCommandResult | undefined {
+		return this.lastResult;
+	}
+
+	/**
+	 * Clean up resources
+	 */
+	async cleanup(): Promise<void> {
+		if (this.tmCore) {
+			await this.tmCore.close();
+			this.tmCore = undefined;
+		}
+	}
+
+	/**
+	 * Static method to register this command on an existing program
+	 */
+	static registerOn(program: Command): Command {
+		const startCommand = new StartCommand();
+		program.addCommand(startCommand);
+		return startCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 */
+	static register(program: Command, name?: string): StartCommand {
+		const startCommand = new StartCommand(name);
+		program.addCommand(startCommand);
+		return startCommand;
+	}
+}

apps/cli/src/index.ts

@@ -8,6 +8,7 @@ export { ListTasksCommand } from './commands/list.command.js';
 export { ShowCommand } from './commands/show.command.js';
 export { AuthCommand } from './commands/auth.command.js';
 export { ContextCommand } from './commands/context.command.js';
+export { StartCommand } from './commands/start.command.js';
 export { SetStatusCommand } from './commands/set-status.command.js';
 
 // UI utilities (for other commands to use)
@@ -17,7 +18,8 @@ export * as ui from './utils/ui.js';
 export {
 	checkForUpdate,
 	performAutoUpdate,
-	displayUpgradeNotification
+	displayUpgradeNotification,
+	compareVersions
 } from './utils/auto-update.js';
 
 // Re-export commonly used types from tm-core

apps/cli/src/ui/components/task-detail.component.ts

@@ -262,3 +262,74 @@ export function displaySuggestedActions(taskId: string | number): void {
 		)
 	);
 }
+
+/**
+ * Display complete task details - used by both show and start commands
+ */
+export function displayTaskDetails(
+	task: Task,
+	options?: {
+		statusFilter?: string;
+		showSuggestedActions?: boolean;
+		customHeader?: string;
+		headerColor?: string;
+	}
+): void {
+	const {
+		statusFilter,
+		showSuggestedActions = false,
+		customHeader,
+		headerColor = 'blue'
+	} = options || {};
+
+	// Display header - either custom or default
+	if (customHeader) {
+		console.log(
+			boxen(chalk.white.bold(customHeader), {
+				padding: { top: 0, bottom: 0, left: 1, right: 1 },
+				borderColor: headerColor,
+				borderStyle: 'round',
+				margin: { top: 1 }
+			})
+		);
+	} else {
+		displayTaskHeader(task.id, task.title);
+	}
+
+	// Display task properties in table format
+	displayTaskProperties(task);
+
+	// Display implementation details if available
+	if (task.details) {
+		console.log(); // Empty line for spacing
+		displayImplementationDetails(task.details);
+	}
+
+	// Display test strategy if available
+	if ('testStrategy' in task && task.testStrategy) {
+		console.log(); // Empty line for spacing
+		displayTestStrategy(task.testStrategy as string);
+	}
+
+	// Display subtasks if available
+	if (task.subtasks && task.subtasks.length > 0) {
+		// Filter subtasks by status if provided
+		const filteredSubtasks = statusFilter
+			? task.subtasks.filter((sub) => sub.status === statusFilter)
+			: task.subtasks;
+
+		if (filteredSubtasks.length === 0 && statusFilter) {
+			console.log(); // Empty line for spacing
+			console.log(chalk.gray(`  No subtasks with status '${statusFilter}'`));
+		} else if (filteredSubtasks.length > 0) {
+			console.log(); // Empty line for spacing
+			displaySubtasks(filteredSubtasks, task.id);
+		}
+	}
+
+	// Display suggested actions if requested
+	if (showSuggestedActions) {
+		console.log(); // Empty line for spacing
+		displaySuggestedActions(task.id);
+	}
+}

apps/cli/src/utils/auto-update.ts

@@ -7,7 +7,6 @@ import https from 'https';
 import chalk from 'chalk';
 import ora from 'ora';
 import boxen from 'boxen';
-import packageJson from '../../../../package.json' with { type: 'json' };
 
 export interface UpdateInfo {
 	currentVersion: string;
@@ -16,15 +15,18 @@ export interface UpdateInfo {
 }
 
 /**
- * Get current version from package.json
+ * Get current version from build-time injected environment variable
  */
 function getCurrentVersion(): string {
-	try {
-		return packageJson.version;
-	} catch (error) {
-		console.warn('Could not read package.json for version info');
-		return '0.0.0';
+	// Version is injected at build time via TM_PUBLIC_VERSION
+	const version = process.env.TM_PUBLIC_VERSION;
+	if (version && version !== 'unknown') {
+		return version;
 	}
+
+	// Fallback for development or if injection failed
+	console.warn('Could not read version from TM_PUBLIC_VERSION, using fallback');
+	return '0.0.0';
 }
 
 /**
@@ -33,7 +35,7 @@ function getCurrentVersion(): string {
  * @param v2 - Second version
  * @returns -1 if v1 < v2, 0 if v1 = v2, 1 if v1 > v2
  */
-function compareVersions(v1: string, v2: string): number {
+export function compareVersions(v1: string, v2: string): number {
 	const toParts = (v: string) => {
 		const [core, pre = ''] = v.split('-', 2);
 		const nums = core.split('.').map((n) => Number.parseInt(n, 10) || 0);

apps/docs/CHANGELOG.md

@@ -1,5 +1,9 @@
 # docs
 
+## 0.0.4
+
+## 0.0.3
+
 ## 0.0.2
 
 ## 0.0.1

apps/docs/archive/Installation.mdx

@@ -19,7 +19,7 @@ description: "This guide walks you through setting up Task Master in your develo
         	"mcpServers": {
         		"taskmaster-ai": {
         			"command": "npx",
-        			"args": ["-y", "--package", "task-master-ai", "task-master-mcp"],
+        			"args": ["-y", "task-master-ai"],
         			"env": {
         				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",

apps/docs/archive/cursor-setup.mdx

@@ -48,7 +48,7 @@ description: "Learn how to set up and use Task Master with Cursor AI"
       <Step title="Configure with the following details:">
         - Name: "Task Master"
         - Type: "Command"
-        - Command: "npx -y --package task-master-ai task-master-mcp"
+        - Command: "npx -y task-master-ai"
       </Step>
       <Step title="Save Settings">
         

apps/docs/getting-started/agents/claude-code.mdx

@@ -0,0 +1,275 @@
+---
+title: Claude Code Setup  
+sidebarTitle: "Claude Code"
+---
+
+<div className="flex items-center space-x-4 mb-6">
+  <img src="/logo/claude-logo.svg" className="w-12 h-12" alt="Claude Code" />
+  <div>
+    <h1 className="text-2xl font-bold">Claude Code</h1>
+    <p className="text-gray-600">Anthropic's official CLI for Claude</p>
+  </div>
+</div>
+
+Claude Code offers the smoothest Task Master experience with **zero API key setup** and direct Claude integration.
+
+## 🎯 Why Choose Claude Code?
+
+<div className="grid grid-cols-1 md:grid-cols-2 gap-4 mb-6">
+  <div className="bg-blue-50 dark:bg-blue-900/20 p-4 rounded-lg border border-blue-200 dark:border-blue-800">
+    <h3 className="font-semibold text-blue-800 dark:text-blue-200 mb-2">🔓 No API Keys</h3>
+    <p className="text-sm text-blue-700 dark:text-blue-300">Uses your existing Claude subscription - no separate API setup needed</p>
+  </div>
+  <div className="bg-green-50 dark:bg-green-900/20 p-4 rounded-lg border border-green-200 dark:border-green-800">
+    <h3 className="font-semibold text-green-800 dark:text-green-200 mb-2">⚡ Native Integration</h3>
+    <p className="text-sm text-green-700 dark:text-green-300">Built specifically for Claude - seamless Task Master experience</p>
+  </div>
+</div>
+
+## 📦 Installation
+
+### Step 1: Install Claude Code
+
+Follow the [official Claude Code installation guide](https://docs.anthropic.com/en/docs/claude-code) or use our quick setup:
+
+<Tabs>
+  <Tab title="macOS">
+    ```bash
+    # Install via Homebrew (recommended)
+    brew install claude-code
+    
+    # Or download from GitHub releases
+    curl -L https://github.com/anthropics/claude-code/releases/latest/download/claude-code-macos.tar.gz | tar xz
+    sudo mv claude-code /usr/local/bin/
+    ```
+  </Tab>
+  
+  <Tab title="Windows">
+    ```powershell
+    # Download and install from GitHub releases
+    # Visit: https://github.com/anthropics/claude-code/releases/latest
+    # Download: claude-code-windows.exe
+    
+    # Or use winget (if available)
+    winget install Anthropic.ClaudeCode
+    ```
+  </Tab>
+  
+  <Tab title="Linux">
+    ```bash
+    # Download from GitHub releases
+    curl -L https://github.com/anthropics/claude-code/releases/latest/download/claude-code-linux.tar.gz | tar xz
+    sudo mv claude-code /usr/local/bin/
+    
+    # Or install via package manager (if available)
+    sudo apt install claude-code  # Ubuntu/Debian
+    sudo yum install claude-code  # RHEL/CentOS
+    ```
+  </Tab>
+</Tabs>
+
+### Step 2: Authenticate with Claude
+
+```bash
+# Login to your Claude account
+claude auth login
+```
+
+Follow the prompts to authenticate with your Anthropic account.
+
+## 🔧 Task Master Integration
+
+### Method 1: MCP Integration (Recommended)
+
+Add Task Master to your Claude Code MCP configuration:
+
+<Tabs>
+  <Tab title="Global Setup">
+    ```bash
+    # Add Task Master MCP server globally
+    claude mcp add task-master-ai -s global -- npx -y task-master-ai
+    ```
+  </Tab>
+  
+  <Tab title="Project Setup">
+    ```bash
+    # Add for current project only  
+    claude mcp add task-master-ai -s project -- npx -y task-master-ai
+    ```
+  </Tab>
+  
+  <Tab title="Windows">
+    ```bash
+    # Windows-specific command
+    claude mcp add task-master-mcp -s project -- cmd /c "npx -y --package=task-master-ai task-master-ai"
+    ```
+  </Tab>
+</Tabs>
+
+### Method 2: Direct CLI Usage
+
+You can also use Task Master commands directly alongside Claude Code:
+
+```bash
+# Initialize Task Master in your project
+npx task-master-ai init
+
+# Use Claude Code for AI interactions
+claude "Help me implement the next task"
+
+# Use Task Master for task management  
+npx task-master-ai next
+npx task-master-ai show 1.2
+```
+
+## 🚀 Getting Started
+
+### 1. Initialize Your Project
+
+In your project directory:
+
+```bash
+# Start Claude Code
+claude
+
+# In the Claude Code chat, initialize Task Master
+Initialize taskmaster-ai in my project
+```
+
+### 2. Configure Models (Optional)
+
+Since Claude Code doesn't need API keys, you can use it as your main model:
+
+```
+Change the main model to claude-code/sonnet
+```
+
+Available Claude Code models:
+- `claude-code/sonnet` - Claude 3.5 Sonnet (recommended)
+- `claude-code/opus` - Claude 3 Opus (for complex tasks)
+
+### 3. Create Your First Tasks
+
+```
+Can you parse my PRD and create tasks for building a todo app?
+```
+
+## 💡 Advanced Configuration
+
+### Hybrid Setup
+
+Use Claude Code as your main model with other APIs for research:
+
+Create `.env` in your project:
+```bash
+# Optional: Add research capabilities
+PERPLEXITY_API_KEY=your_perplexity_key_here
+OPENAI_API_KEY=your_openai_key_here
+```
+
+Then configure models:
+```
+Change the main model to claude-code/sonnet and research model to perplexity-llama-3.1-sonar-large-128k-online
+```
+
+### Multi-Session Workflows
+
+Claude Code excels at parallel development:
+
+```bash
+# Terminal 1: Main development
+cd my-project && claude
+
+# Terminal 2: Testing and validation  
+cd my-project && claude
+
+# Terminal 3: Documentation
+cd my-project && claude
+```
+
+Each session maintains Task Master context while allowing focused work streams.
+
+## 🔍 Troubleshooting
+
+<Accordion title="Claude Code not found">
+- **Check installation**: Run `claude --version` to verify installation
+- **Update PATH**: Ensure Claude Code is in your system PATH
+- **Reinstall**: Try reinstalling Claude Code from scratch
+- **Permissions**: Check file permissions for the claude binary
+</Accordion>
+
+<Accordion title="Authentication issues">
+- **Re-login**: Run `claude auth logout` then `claude auth login`
+- **Check account**: Verify your Anthropic account is active
+- **Network issues**: Check if you're behind a proxy or firewall
+- **Clear cache**: Delete `~/.claude` directory and re-authenticate
+</Accordion>
+
+<Accordion title="MCP server connection fails">
+- **Check Node.js**: Ensure Node.js 16+ is installed
+- **Test manually**: Run `npx task-master-ai` to test the server
+- **Clear MCP cache**: Remove and re-add the MCP server
+- **Check permissions**: Ensure npm can install packages
+</Accordion>
+
+<Accordion title="Task Master commands not working">
+- **Verify MCP**: Run `claude mcp list` to see installed servers
+- **Re-add server**: Remove and re-add the task-master-ai MCP server
+- **Check initialization**: Ensure project is initialized with `Initialize taskmaster-ai`
+- **Review logs**: Check Claude Code logs for error messages
+</Accordion>
+
+## 💡 Pro Tips
+
+<Tip>
+**Use headless mode** for automation: `claude -p "What's the next task I should work on?"` gives quick answers without opening the full chat interface.
+</Tip>
+
+<Tip>
+**Create custom commands** using Claude Code's command system for repeated Task Master workflows like "complete task and get next".
+</Tip>
+
+<Tip>
+**Leverage context persistence** - Claude Code maintains conversation history, making it perfect for long-running development sessions.
+</Tip>
+
+## 🎯 Best Practices
+
+### Development Workflow
+
+```bash
+# Morning routine
+claude "Show me today's tasks and priorities"
+
+# During development  
+claude "Help me implement task 2.1"
+claude "Update task 2.1 with implementation notes"
+
+# End of day
+claude "Mark completed tasks as done and show tomorrow's priorities"
+```
+
+### Team Collaboration
+
+```bash
+# Share task status
+claude "Generate a progress report for the team"
+
+# Review dependencies
+claude "Check which tasks are blocked and why"
+
+# Planning sessions
+claude "Analyze complexity of remaining tasks"
+```
+
+---
+
+<div className="bg-purple-50 dark:bg-purple-900/20 p-4 rounded-lg border border-purple-200 dark:border-purple-800">
+  <div className="flex items-center space-x-2 mb-2">
+    <span className="text-purple-600 dark:text-purple-400 text-lg">🎉</span>
+    <h3 className="font-semibold text-purple-800 dark:text-purple-200">You're all set with Claude Code!</h3>
+  </div>
+  <p className="text-purple-700 dark:text-purple-300">
+    Claude Code offers the most seamless Task Master experience. Ready to create your first project? Check out our <a href="/getting-started/quick-start/prd-quick" className="underline">PRD guide</a>.
+  </p>
+</div>

apps/docs/getting-started/agents/cli.mdx

@@ -0,0 +1,373 @@
+---
+title: Command Line Setup
+sidebarTitle: "CLI"
+---
+
+<div className="flex items-center space-x-4 mb-6">
+  <img src="/logo/terminal-logo.svg" className="w-12 h-12" alt="Terminal" />
+  <div>
+    <h1 className="text-2xl font-bold">Command Line Interface</h1>
+    <p className="text-gray-600">Direct CLI usage without IDE integration</p>
+  </div>
+</div>
+
+Use Task Master directly from the command line for maximum flexibility and control.
+
+## 🎯 Why Choose CLI?
+
+<div className="grid grid-cols-1 md:grid-cols-2 gap-4 mb-6">
+  <div className="bg-blue-50 dark:bg-blue-900/20 p-4 rounded-lg border border-blue-200 dark:border-blue-800">
+    <h3 className="font-semibold text-blue-800 dark:text-blue-200 mb-2">🚀 Maximum Performance</h3>
+    <p className="text-sm text-blue-700 dark:text-blue-300">No IDE overhead - pure command line speed</p>
+  </div>
+  <div className="bg-green-50 dark:bg-green-900/20 p-4 rounded-lg border border-green-200 dark:border-green-800">
+    <h3 className="font-semibold text-green-800 dark:text-green-200 mb-2">🔧 Full Control</h3>
+    <p className="text-sm text-green-700 dark:text-green-300">Access to all Task Master features and configurations</p>
+  </div>
+  <div className="bg-purple-50 dark:bg-purple-900/20 p-4 rounded-lg border border-purple-200 dark:border-purple-800">
+    <h3 className="font-semibold text-purple-800 dark:text-purple-200 mb-2">📜 Scriptable</h3>
+    <p className="text-sm text-purple-700 dark:text-purple-300">Perfect for automation and CI/CD integration</p>
+  </div>
+  <div className="bg-orange-50 dark:bg-orange-900/20 p-4 rounded-lg border border-orange-200 dark:border-orange-800">
+    <h3 className="font-semibold text-orange-800 dark:text-orange-200 mb-2">🌐 Universal</h3>
+    <p className="text-sm text-orange-700 dark:text-orange-300">Works on any system with Node.js</p>
+  </div>
+</div>
+
+## 📦 Installation
+
+### Global Installation (Recommended)
+
+```bash
+# Install Task Master globally
+npm install -g task-master-ai
+
+# Verify installation
+task-master --version
+```
+
+### Local Installation
+
+```bash
+# Install in your project
+npm install task-master-ai
+
+# Use with npx
+npx task-master-ai --version
+```
+
+## 🔧 Configuration
+
+### Step 1: Set Up API Keys
+
+Create a `.env` file in your project root:
+
+```bash
+# At least one of these is required
+ANTHROPIC_API_KEY=your_anthropic_key_here
+PERPLEXITY_API_KEY=your_perplexity_key_here  # Recommended for research
+OPENAI_API_KEY=your_openai_key_here
+
+# Optional additional providers
+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
+```
+
+### Step 2: Configure Models
+
+```bash
+# Interactive model configuration
+task-master models --setup
+
+# Or 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
+```
+
+### Step 3: Initialize Your Project
+
+```bash
+# Initialize Task Master in current directory
+task-master init
+
+# Initialize with specific rules
+task-master init --rules cursor,windsurf,vscode
+```
+
+## 🚀 Quick Start Guide
+
+### 1. Create Your PRD
+
+```bash
+# Create a Product Requirements Document
+touch .taskmaster/docs/prd.txt
+
+# Edit with your favorite editor
+nano .taskmaster/docs/prd.txt
+# or
+code .taskmaster/docs/prd.txt
+```
+
+### 2. Generate Tasks
+
+```bash
+# Parse your PRD and create tasks
+task-master parse-prd .taskmaster/docs/prd.txt
+
+# Analyze task complexity
+task-master analyze-complexity --research
+
+# Expand tasks into subtasks
+task-master expand --all --research
+```
+
+### 3. Start Working
+
+```bash
+# See all tasks
+task-master list
+
+# Get next task to work on
+task-master next
+
+# Show specific task details
+task-master show 1.2
+
+# Mark task as in-progress
+task-master set-status --id=1.2 --status=in-progress
+```
+
+## 📋 Essential Commands
+
+### Task Management
+
+```bash
+# List all tasks
+task-master list
+
+# Show specific tasks (comma-separated)
+task-master show 1,2,3
+
+# Get next available task
+task-master next
+
+# Add a new task
+task-master add-task --prompt="Implement user login" --research
+
+# Update task with notes
+task-master update-task --id=1.2 --prompt="Added JWT authentication"
+
+# Update subtask with implementation notes
+task-master update-subtask --id=1.2.1 --prompt="Used bcrypt for password hashing"
+```
+
+### Task Status Management
+
+```bash
+# Mark task as done
+task-master set-status --id=1.2 --status=done
+
+# Mark as in-progress
+task-master set-status --id=1.2 --status=in-progress
+
+# Mark as blocked
+task-master set-status --id=1.2 --status=blocked
+```
+
+### Analysis and Planning
+
+```bash
+# Research latest information
+task-master research "What are the latest React best practices?"
+
+# Analyze project complexity
+task-master analyze-complexity --research
+
+# View complexity report
+task-master complexity-report
+
+# Expand task into subtasks
+task-master expand --id=1.2 --research --force
+```
+
+### Dependencies and Organization
+
+```bash
+# Add task dependency
+task-master add-dependency --id=2.1 --depends-on=1.2
+
+# Move task to different position
+task-master move --from=3 --to=1
+
+# Validate dependencies
+task-master validate-dependencies
+
+# Generate markdown files
+task-master generate
+```
+
+## 🎯 Advanced Usage
+
+### Scripting and Automation
+
+Create shell scripts for common workflows:
+
+```bash
+#!/bin/bash
+# daily-standup.sh
+
+echo "=== Today's Tasks ==="
+task-master next
+
+echo -e "\n=== In Progress ==="
+task-master list | grep "in-progress"
+
+echo -e "\n=== Blocked Tasks ==="
+task-master list | grep "blocked"
+
+echo -e "\n=== Complexity Report ==="
+task-master complexity-report
+```
+
+### CI/CD Integration
+
+```yaml
+# .github/workflows/task-validation.yml
+name: Task Validation
+
+on: [push, pull_request]
+
+jobs:
+  validate-tasks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '18'
+      
+      - name: Install Task Master
+        run: npm install -g task-master-ai
+        
+      - name: Validate task dependencies
+        run: task-master validate-dependencies
+        
+      - name: Generate task report
+        run: task-master complexity-report > task-report.json
+```
+
+### Custom Aliases
+
+Add these to your `.bashrc` or `.zshrc`:
+
+```bash
+# Task Master shortcuts
+alias tm="task-master"
+alias tmn="task-master next"
+alias tml="task-master list"  
+alias tmr="task-master research"
+alias tms="task-master show"
+```
+
+## 🔍 Troubleshooting
+
+<Accordion title="Command not found: task-master">
+**Solutions:**
+- Verify Node.js installation: `node --version`
+- Reinstall globally: `npm install -g task-master-ai`
+- Check npm global path: `npm config get prefix`
+- Use npx if global install fails: `npx task-master-ai`
+</Accordion>
+
+<Accordion title="API key errors">
+**Solutions:**
+- Check `.env` file exists and has correct keys
+- Verify API key format and validity
+- Test with a single API key first
+- Check for typos in environment variable names
+</Accordion>
+
+<Accordion title="Tasks not generating">
+**Solutions:**
+- Verify PRD file exists and has content
+- Check API keys are working: `task-master models`
+- Try with different model: `task-master models --set-main gpt-4o-mini`
+- Add `--research` flag for better results
+</Accordion>
+
+<Accordion title="Permission errors">
+**Solutions:**
+- Use `sudo` for global installs (not recommended)
+- Configure npm to use different directory: `npm config set prefix ~/.local`
+- Use local installation: `npm install task-master-ai`
+- Check file permissions in `.taskmaster` directory
+</Accordion>
+
+## 💡 Pro Tips
+
+<Tip>
+**Use `--research` flag** with AI commands for more informed and up-to-date task suggestions based on current best practices.
+</Tip>
+
+<Tip>
+**Create project templates** with pre-configured `.taskmaster` directories for different types of projects (web apps, APIs, mobile apps).
+</Tip>
+
+<Tip>
+**Combine with other tools** like `jq` for parsing JSON outputs: `task-master list --json | jq '.[] | select(.status=="pending")'`
+</Tip>
+
+<Tip>
+**Use environment-specific configs** by creating different `.env` files (.env.development, .env.production) and symlinking as needed.
+</Tip>
+
+## 📚 Integration Examples
+
+### With Git Hooks
+
+```bash
+#!/bin/sh
+# .git/hooks/pre-commit
+
+# Check if any tasks are marked as done
+if task-master list | grep -q "done"; then
+    echo "✅ Tasks completed in this commit:"
+    task-master list | grep "done"
+fi
+```
+
+### With Make
+
+```makefile
+# Makefile
+
+.PHONY: tasks next status
+
+tasks:
+	@task-master list
+
+next:
+	@task-master next
+
+status:
+	@echo "=== Task Status ==="
+	@task-master list | grep -E "(in-progress|blocked)"
+	@echo ""
+	@echo "=== Next Task ==="
+	@task-master next
+```
+
+---
+
+<div className="bg-cyan-50 dark:bg-cyan-900/20 p-4 rounded-lg border border-cyan-200 dark:border-cyan-800">
+  <div className="flex items-center space-x-2 mb-2">
+    <span className="text-cyan-600 dark:text-cyan-400 text-lg">⚡</span>
+    <h3 className="font-semibold text-cyan-800 dark:text-cyan-200">Ready for maximum productivity!</h3>
+  </div>
+  <p className="text-cyan-700 dark:text-cyan-300">
+    You now have the full power of Task Master at your fingertips. Create your first project with our <a href="/getting-started/quick-start/prd-quick" className="underline">PRD guide</a>.
+  </p>
+</div>

apps/docs/getting-started/agents/cursor.mdx

@@ -0,0 +1,247 @@
+---
+title: Cursor Setup
+sidebarTitle: "Cursor"
+---
+
+<div className="flex items-center space-x-4 mb-6">
+  <img src="/logo/cursor-logo.svg" className="w-12 h-12" alt="Cursor" />
+  <div>
+    <h1 className="text-2xl font-bold">Cursor AI Editor</h1>
+    <p className="text-gray-600">AI-powered VS Code fork with built-in MCP support</p>
+  </div>
+</div>
+
+Cursor offers the smoothest Task Master experience with one-click installation and native MCP integration.
+
+## 🚀 One-Click Install (Recommended)
+
+<div className="bg-blue-50 dark:bg-blue-900/20 p-4 rounded-lg border border-blue-200 dark:border-blue-800 mb-6">
+  <div className="flex items-center space-x-2 mb-3">
+    <span className="text-blue-600 dark:text-blue-400 text-lg">⚡</span>
+    <h3 className="font-semibold text-blue-800 dark:text-blue-200">Fastest Setup</h3>
+  </div>
+  
+  <a href="cursor://anysphere.cursor-deeplink/mcp/install?name=task-master-ai&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIi0tcGFja2FnZT10YXNrLW1hc3Rlci1haSIsInRhc2stbWFzdGVyLWFpIl0sImVudiI6eyJBTlRIUk9QSUNfQVBJX0tFWSI6IllPVVJfQU5USFJPUElDX0FQSV9LRVlfSEVSRSIsIlBFUlBMRVhJVFlfQVBJX0tFWSI6IllPVVJfUEVSUExFWElUWV9BUElfS0VZX0hFUkUiLCJPUEVOQUlfQVBJX0tFWSI6IllPVVJfT1BFTkFJX0tFWV9IRVJFIiwiR09PR0xFX0FQSV9LRVkiOiJZT1VSX0dPT0dMRV9LRVlfSEVSRSIsIk1JU1RSQUxfQVBJX0tFWSI6IllPVVJfTUlTVFJBTF9LRVlfSEVSRSIsIk9QRU5ST1VURVJfQVBJX0tFWSI6IllPVVJfT1BFTlJPVVRFUl9LRVlfSEVSRSIsIlhBSV9BUElfS0VZIjoiWU9VUl9YQUlfS0VZX0hFUkUiLCJBWlVSRV9PUEVOQUJFX0FQSV9LRVkiOiJZT1VSX0FaVVJFX0tFWV9IRVJFIiwiT0xMQU1BX0FQSV9LRVkiOiJZT1VSX09MTEFNQV9BUElfS0VZX0hFUkUifX0%3D">
+    <img 
+      className="block dark:hidden hover:opacity-80 transition-opacity cursor-pointer" 
+      src="https://cursor.com/deeplink/mcp-install-light.png" 
+      alt="Add Task Master MCP server to Cursor" 
+      noZoom
+    />
+    <img 
+      className="hidden dark:block hover:opacity-80 transition-opacity cursor-pointer" 
+      src="https://cursor.com/deeplink/mcp-install-dark.png" 
+      alt="Add Task Master MCP server to Cursor" 
+      noZoom
+    />
+  </a>
+</div>
+
+<Warning>
+**After one-click install**: You still need to add your actual API keys! The installer uses placeholder keys that must be replaced.
+</Warning>
+
+## 📋 Manual Setup
+
+If you prefer manual configuration or the one-click install doesn't work:
+
+### Step 1: Create MCP Configuration
+
+Choose your configuration scope:
+
+<Tabs>
+  <Tab title="Global Config">
+    Create or edit `~/.cursor/mcp.json` (macOS/Linux) or `%USERPROFILE%\.cursor\mcp.json` (Windows):
+
+    ```json
+    {
+      "mcpServers": {
+        "task-master-ai": {
+          "command": "npx",
+          "args": ["-y", "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"
+          }
+        }
+      }
+    }
+    ```
+  </Tab>
+  
+  <Tab title="Project Config">
+    Create `.cursor/mcp.json` in your project root:
+
+    ```json
+    {
+      "mcpServers": {
+        "task-master-ai": {
+          "command": "npx",
+          "args": ["-y", "task-master-ai"],
+          "env": {
+            "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
+            "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE"
+          }
+        }
+      }
+    }
+    ```
+  </Tab>
+  
+  <Tab title="Windows Native">
+    For Windows users without WSL:
+
+    ```json
+    {
+      "mcpServers": {
+        "task-master-ai": {
+          "command": "cmd",
+          "args": ["/c", "npx -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"
+          }
+        }
+      }
+    }
+    ```
+
+    <Note>
+    **Alternative Windows Setup**: Use Claude Code's project-level installation:
+    ```bash
+    claude mcp add task-master-mcp -s project -- cmd /c "npx -y --package=task-master-ai task-master-ai"
+    ```
+    </Note>
+  </Tab>
+</Tabs>
+
+### Step 2: Enable MCP Server
+
+1. Open Cursor Settings (`Ctrl+Shift+J` or `Cmd+Shift+J`)
+2. Click the **MCP** tab in the left sidebar
+3. Find `task-master-ai` and toggle it **ON**
+4. Restart Cursor if needed
+
+### Step 3: Verify Installation
+
+In Cursor's chat panel, type:
+```
+help
+```
+
+You should see Task Master commands available. If you see "0 tools enabled", check your API keys and restart Cursor.
+
+## 🔧 Configuration
+
+### Add Your API Keys
+
+<Tabs>
+  <Tab title="Required Keys">
+    You need **at least one** of these:
+    - `ANTHROPIC_API_KEY` - For Claude models (recommended)
+    - `OPENAI_API_KEY` - For GPT models  
+    - `GOOGLE_API_KEY` - For Gemini models
+  </Tab>
+  
+  <Tab title="Recommended Keys">
+    For the best experience, also add:
+    - `PERPLEXITY_API_KEY` - Enables research features
+    - `OPENAI_API_KEY` - Fallback option
+  </Tab>
+  
+  <Tab title="All Supported Keys">
+    Full list of supported API keys:
+    - `ANTHROPIC_API_KEY`
+    - `PERPLEXITY_API_KEY` 
+    - `OPENAI_API_KEY`
+    - `GOOGLE_API_KEY`
+    - `MISTRAL_API_KEY`
+    - `OPENROUTER_API_KEY`
+    - `XAI_API_KEY`
+    - `AZURE_OPENAI_API_KEY`
+    - `OLLAMA_API_KEY`
+  </Tab>
+</Tabs>
+
+### Configure Models (Optional)
+
+In Cursor's chat, set your preferred models:
+
+```
+Change the main, research and fallback models to claude-3-5-sonnet-20241022, perplexity-llama-3.1-sonar-large-128k-online and gpt-4o-mini respectively.
+```
+
+## 🎯 Getting Started
+
+### 1. Initialize Task Master
+
+In Cursor's chat panel:
+```
+Initialize taskmaster-ai in my project
+```
+
+### 2. Create Your First Task
+
+```
+Can you help me implement user authentication for my web app?
+```
+
+### 3. Start Working
+
+```
+What's the next task I should work on?
+```
+
+## 🔍 Troubleshooting
+
+<Accordion title="0 tools enabled in MCP settings">
+- **Check API keys**: Ensure at least one API key is correctly set
+- **Restart Cursor**: Close and reopen Cursor completely  
+- **Check file paths**: Verify your `mcp.json` is in the correct location
+- **Test manually**: Run `npx task-master-ai` in terminal to test
+</Accordion>
+
+<Accordion title="MCP server fails to start">
+- **Update Node.js**: Ensure you have Node.js 16+ installed
+- **Clear npm cache**: Run `npm cache clean --force`
+- **Try global install**: Run `npm install -g task-master-ai`
+- **Check permissions**: Ensure npm has permission to install packages
+</Accordion>
+
+<Accordion title="Commands not working">
+- **Verify installation**: Type `help` in chat to see available commands
+- **Check project initialization**: Run `Initialize taskmaster-ai in my project`
+- **Review logs**: Check Cursor's developer console for error messages
+</Accordion>
+
+## 💡 Pro Tips
+
+<Tip>
+**Use project-specific configs** for different API keys per project, especially when working with team projects that have shared API limits.
+</Tip>
+
+<Tip>
+**Enable research mode** with a Perplexity API key to get AI-powered task suggestions based on the latest best practices.
+</Tip>
+
+<Tip>
+**Set up keyboard shortcuts** in Cursor for common Task Master commands like "What's next?" or "Show task status".
+</Tip>
+
+---
+
+<div className="bg-green-50 dark:bg-green-900/20 p-4 rounded-lg border border-green-200 dark:border-green-800">
+  <div className="flex items-center space-x-2 mb-2">
+    <span className="text-green-600 dark:text-green-400 text-lg">✅</span>
+    <h3 className="font-semibold text-green-800 dark:text-green-200">Ready to go!</h3>
+  </div>
+  <p className="text-green-700 dark:text-green-300">
+    You're all set with Cursor! Head over to our <a href="/getting-started/quick-start/prd-quick" className="underline">PRD guide</a> to create your first project.
+  </p>
+</div>

apps/docs/getting-started/ai-agents.mdx

@@ -0,0 +1,118 @@
+---
+title: Choose Your AI Agent
+sidebarTitle: "AI Agents"
+---
+
+Task Master works seamlessly with various AI agents. Choose your preferred agent to get customized setup instructions.
+
+<CardGroup cols={2}>
+  <Card 
+    title="Cursor" 
+    icon="cursor" 
+    href="/getting-started/agents/cursor"
+  >
+    <div className="flex items-center space-x-3">
+      <img src="/logo/cursor-logo.svg" className="w-8 h-8" alt="Cursor" />
+      <span>AI-powered VS Code fork with built-in MCP support</span>
+    </div>
+  </Card>
+
+  <Card 
+    title="Claude Code" 
+    icon="claude" 
+    href="/getting-started/agents/claude-code"
+  >
+    <div className="flex items-center space-x-3">
+      <img src="/logo/claude-logo.svg" className="w-8 h-8" alt="Claude Code" />
+      <span>Anthropic's official CLI for Claude</span>
+    </div>
+  </Card>
+
+  <Card 
+    title="Windsurf" 
+    icon="windsurf" 
+    href="/getting-started/agents/windsurf"
+  >
+    <div className="flex items-center space-x-3">
+      <img src="/logo/windsurf-logo.svg" className="w-8 h-8" alt="Windsurf" />
+      <span>Codeium's AI-native IDE</span>
+    </div>
+  </Card>
+
+  <Card 
+    title="VS Code" 
+    icon="vscode" 
+    href="/getting-started/agents/vscode"
+  >
+    <div className="flex items-center space-x-3">
+      <img src="/logo/vscode-logo.svg" className="w-8 h-8" alt="VS Code" />
+      <span>Microsoft's editor with MCP extensions</span>
+    </div>
+  </Card>
+
+  <Card 
+    title="Command Line" 
+    icon="terminal" 
+    href="/getting-started/agents/cli"
+  >
+    <div className="flex items-center space-x-3">
+      <img src="/logo/terminal-logo.svg" className="w-8 h-8" alt="Terminal" />
+      <span>Direct CLI usage without IDE integration</span>
+    </div>
+  </Card>
+
+  <Card 
+    title="Other Agents" 
+    icon="question" 
+    href="/getting-started/agents/other"
+  >
+    <div className="flex items-center space-x-3">
+      <img src="/logo/generic-logo.svg" className="w-8 h-8" alt="Other" />
+      <span>Generic setup for other AI agents</span>
+    </div>
+  </Card>
+</CardGroup>
+
+## Quick Recommendations
+
+<Accordion title="🎯 Which agent should I choose?">
+**For beginners**: Start with **Cursor** - it has the most seamless MCP integration and one-click install.
+
+**For Claude users**: Use **Claude Code** - it's Anthropic's official CLI with no API key required.
+
+**For existing VS Code users**: Stick with **VS Code** if you're already comfortable with your setup.
+
+**For advanced users**: Try **Windsurf** for its AI-native features or use **Command Line** for maximum flexibility.
+</Accordion>
+
+<Accordion title="💡 What's MCP and why does it matter?">
+MCP (Model Control Protocol) allows Task Master to run directly inside your AI agent, giving you:
+- 🔥 **Seamless integration** - No switching between tools
+- ⚡ **Real-time task management** - Tasks update as you work  
+- 🧠 **Context awareness** - Your AI knows about your tasks
+- 🎯 **Smart suggestions** - AI can recommend next tasks
+</Accordion>
+
+## Platform-Specific Notes
+
+<Tabs>
+  <Tab title="Windows">
+    **Important**: Windows users may need special configuration for some agents. We'll provide Windows-specific instructions for each agent.
+    
+    Some agents work better with WSL (Windows Subsystem for Linux), while others have native Windows support.
+  </Tab>
+  
+  <Tab title="macOS">
+    Most agents work seamlessly on macOS. Claude Code and Cursor have the best native macOS integration.
+  </Tab>
+  
+  <Tab title="Linux">
+    All agents have excellent Linux support. Command Line interface works particularly well in Linux environments.
+  </Tab>
+</Tabs>
+
+---
+
+<Note>
+**Need help choosing?** Check our [comparison table](/getting-started/agent-comparison) or join our [Discord community](https://discord.gg/taskmasterai) for personalized recommendations.
+</Note>

apps/docs/getting-started/quick-start/configuration-quick.mdx

@@ -18,8 +18,8 @@ For MCP/Cursor usage: Configure keys in the env section of your .cursor/mcp.json
 {
 	"mcpServers": {
 		"task-master-ai": {
-			"command": "node",
-			"args": ["./mcp-server/server.js"],
+			"command": "npx",
+			"args": ["-y", "task-master-ai"],
 			"env": {
 				"ANTHROPIC_API_KEY": "ANTHROPIC_API_KEY_HERE",
 				"PERPLEXITY_API_KEY": "PERPLEXITY_API_KEY_HERE",

apps/docs/getting-started/quick-start/installation.mdx

@@ -56,7 +56,7 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
   "mcpServers": {
     "taskmaster-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
@@ -75,7 +75,37 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
 
 > 🔑 Replace `YOUR_…_KEY_HERE` with your real API keys. You can remove keys you don't use.
 
-> **Note**: If you see `0 tools enabled` in the MCP settings, try removing the `--package=task-master-ai` flag from `args`.
+> **Note**: If you see `0 tools enabled` in the MCP settings, restart your editor and check that your API keys are correctly configured.
+
+### Windows-specific Configuration
+
+For Windows users without WSL, you may need to use `cmd` to run the MCP server:
+
+```json
+{
+  "mcpServers": {
+    "task-master-ai": {
+      "command": "cmd",
+      "args": ["/c", "npx -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"
+      }
+    }
+  }
+}
+```
+
+Alternatively, you can install at the project level with Claude Code:
+```bash
+claude mcp add task-master-mcp -s project -- cmd /c "npx -y --package=task-master-ai task-master-ai"
+```
 
 ### VS Code (`servers` + `type`)
 
@@ -84,7 +114,7 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
   "servers": {
     "taskmaster-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",

apps/docs/getting-started/quick-start/quick-start.mdx

@@ -5,7 +5,27 @@ sidebarTitle: "Quick Start"
 
 This guide is for new users who want to start using Task Master with minimal setup time.
 
-It covers:
+## 🎯 Choose Your AI Agent
+
+First, pick your preferred AI development environment:
+
+<CardGroup cols={3}>
+  <Card title="Cursor" icon="cursor" href="/getting-started/agents/cursor">
+    One-click install with native MCP support
+  </Card>
+  <Card title="Claude Code" icon="claude" href="/getting-started/agents/claude-code">
+    No API keys needed - uses your Claude subscription
+  </Card>
+  <Card title="Command Line" icon="terminal" href="/getting-started/agents/cli">
+    Maximum control and scriptability
+  </Card>
+</CardGroup>
+
+[View all AI agents →](/getting-started/ai-agents)
+
+## 📋 Quick Start Steps
+
+After setting up your AI agent, this guide covers:
 - [Requirements](/docs/getting-started/quick-start/requirements): You will need Node.js and an AI model API Key.
 - [Installation](/docs/getting-started/quick-start/installation): How to Install Task Master.
 - [Configuration](/docs/getting-started/quick-start/configuration-quick): Setting up your API Key, MCP, and more.

apps/docs/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "docs",
-	"version": "0.0.2",
+	"version": "0.0.4",
 	"private": true,
 	"description": "Task Master documentation powered by Mintlify",
 	"scripts": {

apps/extension/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Change Log
 
+## 0.25.4
+
+### Patch Changes
+
+- Updated dependencies [[`af53525`](https://github.com/eyaltoledano/claude-task-master/commit/af53525cbc660a595b67d4bb90d906911c71f45d)]:
+  - task-master-ai@0.27.3
+
+## 0.25.3
+
+### Patch Changes
+
+- Updated dependencies [[`044a7bf`](https://github.com/eyaltoledano/claude-task-master/commit/044a7bfc98049298177bc655cf341d7a8b6a0011)]:
+  - task-master-ai@0.27.2
+
+## 0.25.2
+
+### Patch Changes
+
+- Updated dependencies [[`f487736`](https://github.com/eyaltoledano/claude-task-master/commit/f487736670ef8c484059f676293777eabb249c9e), [`c911608`](https://github.com/eyaltoledano/claude-task-master/commit/c911608f60454253f4e024b57ca84e5a5a53f65c), [`1a18794`](https://github.com/eyaltoledano/claude-task-master/commit/1a1879483b86c118a4e46c02cbf4acebfcf6bcf9)]:
+  - task-master-ai@0.27.1
+
+## 0.25.2-rc.1
+
+### Patch Changes
+
+- Updated dependencies [[`1a18794`](https://github.com/eyaltoledano/claude-task-master/commit/1a1879483b86c118a4e46c02cbf4acebfcf6bcf9)]:
+  - task-master-ai@0.27.1-rc.1
+
+## 0.25.2-rc.0
+
+### Patch Changes
+
+- Updated dependencies [[`f487736`](https://github.com/eyaltoledano/claude-task-master/commit/f487736670ef8c484059f676293777eabb249c9e)]:
+  - task-master-ai@0.27.1-rc.0
+
+## 0.25.0
+
+### Minor Changes
+
+- [#1200](https://github.com/eyaltoledano/claude-task-master/pull/1200) [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add "Start Task" button to VS Code extension for seamless Claude Code integration
+
+  You can now click a "Start Task" button directly in the Task Master extension which will open a new terminal and automatically execute the task using Claude Code. This provides a seamless workflow from viewing tasks in the extension to implementing them without leaving VS Code.
+
+- [#1201](https://github.com/eyaltoledano/claude-task-master/pull/1201) [`83af314`](https://github.com/eyaltoledano/claude-task-master/commit/83af314879fc0e563581161c60d2bd089899313e) Thanks [@losolosol](https://github.com/losolosol)! - Added a Start Build button to the VSCODE Task Properties Right Panel
+
+### Patch Changes
+
+- [#1229](https://github.com/eyaltoledano/claude-task-master/pull/1229) [`674d1f6`](https://github.com/eyaltoledano/claude-task-master/commit/674d1f6de7ea98116b61bdae6198bafe6c4e7c1a) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix MCP not connecting to new Taskmaster version
+
+- Updated dependencies [[`4e12643`](https://github.com/eyaltoledano/claude-task-master/commit/4e126430a092fb54afb035514fb3d46115714f97), [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142), [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142), [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142), [`a621ff0`](https://github.com/eyaltoledano/claude-task-master/commit/a621ff05eafb51a147a9aabd7b37ddc0e45b0869), [`e6de285`](https://github.com/eyaltoledano/claude-task-master/commit/e6de285ceacb0a397e952a63435cd32a9c731515), [`fce8414`](https://github.com/eyaltoledano/claude-task-master/commit/fce841490a9ebbf1801a42dd8a29397379cf1142)]:
+  - task-master-ai@0.27.0
+
 ## 0.25.0-rc.0
 
 ### Minor Changes

apps/extension/README.md

@@ -109,7 +109,7 @@ Access settings via **File → Preferences → Settings** and search for "Taskma
 
 ### **MCP Connection Settings**
 - **MCP Server Command** - Path to task-master-ai executable (default: `npx`)
-- **MCP Server Args** - Arguments for the server command (default: `-y`, `--package=task-master-ai`, `task-master-ai`)
+- **MCP Server Args** - Arguments for the server command (default: `-y`, `task-master-ai`)
 - **Connection Timeout** - Server response timeout (default: 30s)
 - **Auto Refresh** - Enable automatic task updates (default: enabled)
 

apps/extension/package.json

@@ -3,7 +3,7 @@
 	"private": true,
 	"displayName": "TaskMaster",
 	"description": "A visual Kanban board interface for TaskMaster projects in VS Code",
-	"version": "0.25.0-rc.0",
+	"version": "0.25.4",
 	"publisher": "Hamster",
 	"icon": "assets/icon.png",
 	"engines": {
@@ -240,7 +240,7 @@
 		"check-types": "tsc --noEmit"
 	},
 	"dependencies": {
-		"task-master-ai": "*"
+		"task-master-ai": "0.27.3"
 	},
 	"devDependencies": {
 		"@dnd-kit/core": "^6.3.1",
@@ -254,8 +254,9 @@
 		"@radix-ui/react-separator": "^1.1.7",
 		"@radix-ui/react-slot": "^1.2.3",
 		"@tailwindcss/postcss": "^4.1.11",
+		"@tanstack/react-query": "^5.83.0",
 		"@types/mocha": "^10.0.10",
-		"@types/node": "20.x",
+		"@types/node": "^22.10.5",
 		"@types/react": "19.1.8",
 		"@types/react-dom": "19.1.6",
 		"@types/vscode": "^1.101.0",
@@ -271,12 +272,11 @@
 		"lucide-react": "^0.525.0",
 		"npm-run-all": "^4.1.5",
 		"postcss": "8.5.6",
+		"react": "^19.0.0",
+		"react-dom": "^19.0.0",
 		"tailwind-merge": "^3.3.1",
 		"tailwindcss": "4.1.11",
-		"typescript": "^5.8.3",
-		"@tanstack/react-query": "^5.83.0",
-		"react": "^19.0.0",
-		"react-dom": "^19.0.0"
+		"typescript": "^5.7.3"
 	},
 	"overrides": {
 		"glob@<8": "^10.4.5",

apps/extension/package.publish.json

@@ -95,7 +95,7 @@
 					"items": {
 						"type": "string"
 					},
-					"default": ["-y", "--package=task-master-ai", "task-master-ai"],
+					"default": ["-y", "task-master-ai"],
 					"description": "An array of arguments to pass to the MCP server command."
 				},
 				"taskmaster.mcp.cwd": {

apps/extension/src/components/TaskDetails/TaskMetadataSidebar.tsx

@@ -11,7 +11,6 @@ interface TaskMetadataSidebarProps {
 	tasks: TaskMasterTask[];
 	complexity: any;
 	isSubtask: boolean;
-	sendMessage: (message: any) => Promise<any>;
 	onStatusChange: (status: TaskMasterTask['status']) => void;
 	onDependencyClick: (depId: string) => void;
 	isRegenerating?: boolean;
@@ -23,13 +22,12 @@ export const TaskMetadataSidebar: React.FC<TaskMetadataSidebarProps> = ({
 	tasks,
 	complexity,
 	isSubtask,
-	sendMessage,
 	onStatusChange,
 	onDependencyClick,
 	isRegenerating = false,
 	isAppending = false
 }) => {
-	const { vscode } = useVSCodeContext();
+	const { sendMessage } = useVSCodeContext();
 	const [isLoadingComplexity, setIsLoadingComplexity] = useState(false);
 	const [mcpComplexityScore, setMcpComplexityScore] = useState<
 		number | undefined
@@ -101,26 +99,37 @@ export const TaskMetadataSidebar: React.FC<TaskMetadataSidebarProps> = ({
 	};
 
 	// Handle starting a task
-	const handleStartTask = () => {
+	const handleStartTask = async () => {
 		if (!currentTask || isStartingTask) {
 			return;
 		}
 
 		setIsStartingTask(true);
 
-		// Send message to extension to open terminal
-		if (vscode) {
-			vscode.postMessage({
+		try {
+			// Send message to extension to open terminal
+			const result = await sendMessage({
 				type: 'openTerminal',
-				taskId: currentTask.id,
-				taskTitle: currentTask.title
+				data: {
+					taskId: currentTask.id,
+					taskTitle: currentTask.title
+				}
 			});
-		}
 
-		// Reset loading state after a short delay
-		setTimeout(() => {
+			// Handle the response
+			if (result && !result.success) {
+				console.error('Terminal execution failed:', result.error);
+				// The extension will show VS Code error notification and webview toast
+			} else if (result && result.success) {
+				console.log('Terminal started successfully:', result.terminalName);
+			}
+		} catch (error) {
+			console.error('Failed to start task:', error);
+			// This handles network/communication errors
+		} finally {
+			// Reset loading state
 			setIsStartingTask(false);
-		}, 500);
+		}
 	};
 
 	// Effect to handle complexity on task change

apps/extension/src/components/TaskDetailsView.tsx

@@ -208,7 +208,6 @@ export const TaskDetailsView: React.FC<TaskDetailsViewProps> = ({
 					tasks={allTasks}
 					complexity={complexity}
 					isSubtask={isSubtask}
-					sendMessage={sendMessage}
 					onStatusChange={handleStatusChange}
 					onDependencyClick={handleDependencyClick}
 				/>

apps/extension/src/extension.ts

@@ -8,6 +8,7 @@ import { ConfigService } from './services/config-service';
 import { PollingService } from './services/polling-service';
 import { createPollingStrategy } from './services/polling-strategies';
 import { TaskRepository } from './services/task-repository';
+import { TerminalManager } from './services/terminal-manager';
 import { WebviewManager } from './services/webview-manager';
 import { EventEmitter } from './utils/event-emitter';
 import { ExtensionLogger } from './utils/logger';
@@ -22,6 +23,7 @@ let logger: ExtensionLogger;
 let mcpClient: MCPClientManager;
 let api: TaskMasterApi;
 let repository: TaskRepository;
+let terminalManager: TerminalManager;
 let pollingService: PollingService;
 let webviewManager: WebviewManager;
 let events: EventEmitter;
@@ -46,6 +48,9 @@ export async function activate(context: vscode.ExtensionContext) {
 		// Repository with caching (actually useful for performance)
 		repository = new TaskRepository(api, logger);
 
+		// Terminal manager for task execution
+		terminalManager = new TerminalManager(context, logger);
+
 		// Config service for TaskMaster config.json
 		configService = new ConfigService(logger);
 
@@ -56,7 +61,13 @@ export async function activate(context: vscode.ExtensionContext) {
 		pollingService = new PollingService(repository, strategy, logger);
 
 		// Webview manager (cleaner than global panel array) - create before connection
-		webviewManager = new WebviewManager(context, repository, events, logger);
+		webviewManager = new WebviewManager(
+			context,
+			repository,
+			events,
+			logger,
+			terminalManager
+		);
 		webviewManager.setConfigService(configService);
 
 		// Sidebar webview manager
@@ -210,10 +221,11 @@ function registerCommands(context: vscode.ExtensionContext) {
 	);
 }
 
-export function deactivate() {
+export async function deactivate() {
 	logger?.log('👋 TaskMaster Extension deactivating...');
 	pollingService?.stop();
 	webviewManager?.dispose();
+	await terminalManager?.dispose();
 	api?.destroy();
 	mcpClient?.disconnect();
 }

apps/extension/src/services/terminal-manager.ts

@@ -0,0 +1,156 @@
+/**
+ * Terminal Manager - Handles task execution in VS Code terminals
+ * Uses @tm/core for consistent task management with the CLI
+ */
+
+import * as vscode from 'vscode';
+import { createTaskMasterCore, type TaskMasterCore } from '@tm/core';
+import type { ExtensionLogger } from '../utils/logger';
+
+export interface TerminalExecutionOptions {
+	taskId: string;
+	taskTitle: string;
+	tag?: string;
+}
+
+export interface TerminalExecutionResult {
+	success: boolean;
+	error?: string;
+	terminalName?: string;
+}
+
+export class TerminalManager {
+	private terminals = new Map<string, vscode.Terminal>();
+	private tmCore?: TaskMasterCore;
+
+	constructor(
+		private context: vscode.ExtensionContext,
+		private logger: ExtensionLogger
+	) {}
+
+	/**
+	 * Execute a task in a new VS Code terminal with Claude
+	 * Uses @tm/core for consistent task management with the CLI
+	 */
+	async executeTask(
+		options: TerminalExecutionOptions
+	): Promise<TerminalExecutionResult> {
+		const { taskTitle, tag } = options;
+		// Ensure taskId is always a string
+		const taskId = String(options.taskId);
+
+		this.logger.log(
+			`Starting task execution for ${taskId}: ${taskTitle}${tag ? ` (tag: ${tag})` : ''}`
+		);
+		this.logger.log(`TaskId type: ${typeof taskId}, value: ${taskId}`);
+
+		try {
+			// Initialize tm-core if needed
+			await this.initializeCore();
+
+			// Use tm-core to start the task (same as CLI)
+			const startResult = await this.tmCore!.startTask(taskId, {
+				dryRun: false,
+				force: false,
+				updateStatus: true
+			});
+
+			if (!startResult.started || !startResult.executionOutput) {
+				throw new Error(
+					startResult.error || 'Failed to start task with tm-core'
+				);
+			}
+
+			// Create terminal with custom TaskMaster icon
+			const terminalName = `Task ${taskId}: ${taskTitle}`;
+			const terminal = this.createTerminal(terminalName);
+
+			// Store terminal reference for potential cleanup
+			this.terminals.set(taskId, terminal);
+
+			// Show terminal and run Claude command
+			terminal.show();
+			const command = `claude "${startResult.executionOutput}"`;
+			terminal.sendText(command);
+
+			this.logger.log(`Launched Claude for task ${taskId} using tm-core`);
+
+			return {
+				success: true,
+				terminalName
+			};
+		} catch (error) {
+			this.logger.error('Failed to execute task:', error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : 'Unknown error'
+			};
+		}
+	}
+
+	/**
+	 * Create a new terminal with TaskMaster branding
+	 */
+	private createTerminal(name: string): vscode.Terminal {
+		const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+
+		return vscode.window.createTerminal({
+			name,
+			cwd: workspaceRoot,
+			iconPath: new vscode.ThemeIcon('play') // Use a VS Code built-in icon for now
+		});
+	}
+
+	/**
+	 * Initialize TaskMaster Core (same as CLI)
+	 */
+	private async initializeCore(): Promise<void> {
+		if (!this.tmCore) {
+			const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+			if (!workspaceRoot) {
+				throw new Error('No workspace folder found');
+			}
+			this.tmCore = await createTaskMasterCore({ projectPath: workspaceRoot });
+		}
+	}
+
+	/**
+	 * Get terminal by task ID (if still active)
+	 */
+	getTerminalByTaskId(taskId: string): vscode.Terminal | undefined {
+		return this.terminals.get(taskId);
+	}
+
+	/**
+	 * Clean up terminated terminals
+	 */
+	cleanupTerminal(taskId: string): void {
+		const terminal = this.terminals.get(taskId);
+		if (terminal) {
+			this.terminals.delete(taskId);
+		}
+	}
+
+	/**
+	 * Dispose all managed terminals and clean up tm-core
+	 */
+	async dispose(): Promise<void> {
+		this.terminals.forEach((terminal) => {
+			try {
+				terminal.dispose();
+			} catch (error) {
+				this.logger.error('Failed to dispose terminal:', error);
+			}
+		});
+		this.terminals.clear();
+
+		if (this.tmCore) {
+			try {
+				await this.tmCore.close();
+				this.tmCore = undefined;
+			} catch (error) {
+				this.logger.error('Failed to close tm-core:', error);
+			}
+		}
+	}
+}

apps/extension/src/services/webview-manager.ts

@@ -8,6 +8,7 @@ import type { EventEmitter } from '../utils/event-emitter';
 import type { ExtensionLogger } from '../utils/logger';
 import type { ConfigService } from './config-service';
 import type { TaskRepository } from './task-repository';
+import type { TerminalManager } from './terminal-manager';
 
 export class WebviewManager {
 	private panels = new Set<vscode.WebviewPanel>();
@@ -19,7 +20,8 @@ export class WebviewManager {
 		private context: vscode.ExtensionContext,
 		private repository: TaskRepository,
 		private events: EventEmitter,
-		private logger: ExtensionLogger
+		private logger: ExtensionLogger,
+		private terminalManager: TerminalManager
 	) {}
 
 	setConfigService(configService: ConfigService): void {
@@ -362,27 +364,67 @@ export class WebviewManager {
 					return;
 
 				case 'openTerminal':
-					// Open VS Code terminal for task execution
+					// Delegate terminal execution to TerminalManager
+					const { taskId, taskTitle } = data.data || data; // Handle both nested and direct data
 					this.logger.log(
-						`Opening terminal for task ${data.taskId}: ${data.taskTitle}`
+						`Webview openTerminal - taskId: ${taskId} (type: ${typeof taskId}), taskTitle: ${taskTitle}`
 					);
 
-					try {
-						const terminal = vscode.window.createTerminal({
-							name: `Task ${data.taskId}: ${data.taskTitle}`,
-							cwd: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
-						});
-						terminal.show();
+					// Get current tag to ensure we're working in the right context
+					let currentTag = 'master'; // default fallback
+					if (this.mcpClient) {
+						try {
+							const tagsResult = await this.mcpClient.callTool('list_tags', {
+								projectRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath,
+								showMetadata: false
+							});
 
-						this.logger.log('Terminal created and shown successfully');
-						response = { success: true };
-					} catch (error) {
-						this.logger.error('Failed to create terminal:', error);
-						response = {
-							success: false,
-							error: error instanceof Error ? error.message : 'Unknown error'
-						};
+							let parsedData;
+							if (
+								tagsResult?.content &&
+								Array.isArray(tagsResult.content) &&
+								tagsResult.content[0]?.text
+							) {
+								try {
+									parsedData = JSON.parse(tagsResult.content[0].text);
+									if (parsedData?.data?.currentTag) {
+										currentTag = parsedData.data.currentTag;
+									}
+								} catch (e) {
+									this.logger.warn(
+										'Failed to parse tags response for terminal execution'
+									);
+								}
+							}
+						} catch (error) {
+							this.logger.warn(
+								'Failed to get current tag for terminal execution:',
+								error
+							);
+						}
 					}
+
+					const result = await this.terminalManager.executeTask({
+						taskId,
+						taskTitle,
+						tag: currentTag
+					});
+
+					response = result;
+
+					// Show user feedback AFTER sending the response (like the working "TaskMaster connected!" example)
+					setImmediate(() => {
+						if (result.success) {
+							// Success: Show info message
+							vscode.window.showInformationMessage(
+								`✅ Started Claude session for Task ${taskId}: ${taskTitle}`
+							);
+						} else {
+							// Error: Show VS Code native error notification only
+							const errorMsg = `Failed to start task: ${result.error}`;
+							vscode.window.showErrorMessage(errorMsg);
+						}
+					});
 					break;
 
 				default:

apps/extension/src/utils/mcpClient.ts

@@ -408,7 +408,7 @@ export function createMCPConfigFromSettings(): MCPConfig {
 			const taskMasterPath = require.resolve('task-master-ai');
 			const mcpServerPath = path.resolve(
 				path.dirname(taskMasterPath),
-				'mcp-server/server.js'
+				'./dist/mcp-server.js'
 			);
 
 			// Verify the server file exists

apps/extension/tsconfig.json

@@ -20,7 +20,8 @@
 		"paths": {
 			"@/*": ["./src/*"],
 			"@/components/*": ["./src/components/*"],
-			"@/lib/*": ["./src/lib/*"]
+			"@/lib/*": ["./src/lib/*"],
+			"@tm/core": ["../core/src"]
 		}
 	},
 	"exclude": ["node_modules", ".vscode-test", "out", "dist"]

assets/AGENTS.md

@@ -85,7 +85,7 @@ Task Master provides an MCP server that Claude Code can connect to. Configure in
   "mcpServers": {
     "task-master-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
         "ANTHROPIC_API_KEY": "your_key_here",
         "PERPLEXITY_API_KEY": "your_key_here",