Version Packages (#1249)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Ralph Khreish <35776126+Crunchyman-ralph@users.noreply.github.com>

.changeset/config.json

@@ -8,10 +8,8 @@
   ],
   "commit": false,
   "fixed": [],
-  "linked": [],
   "access": "public",
   "baseBranch": "main",
-  "updateInternalDependencies": "patch",
   "ignore": [
     "docs"
   ]

.changeset/crazy-meals-hope.md

@@ -1,27 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add cross-tag task movement functionality for organizing tasks across different contexts.
-
-This feature enables moving tasks between different tags (contexts) in your project, making it easier to organize work across different branches, environments, or project phases.
-
-## CLI Usage Examples
-
-Move a single task from one tag to another:
-```bash
-# Move task 5 from backlog tag to in-progress tag
-task-master move --from=5 --from-tag=backlog --to-tag=feature-1
-
-# Move task with its dependencies
-task-master move --from=5 --from-tag=backlog --to-tag=feature-2 --with-dependencies
-
-# Move task without checking dependencies
-task-master move --from=5 --from-tag=backlog --to-tag=bug-3 --ignore-dependencies
-```
-
-Move multiple tasks at once:
-```bash
-# Move multiple tasks between tags
-task-master move --from=5,6,7 --from-tag=backlog --to-tag=bug-4 --with-dependencies
-```

.changeset/curly-poets-move.md

@@ -1,6 +0,0 @@
----
-"extension": minor
-"task-master-ai": minor
----
-
-"Add Kilo Code profile integration with custom modes and MCP configuration"

.changeset/cute-files-pay.md

@@ -1,12 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add compact mode --compact / -c flag to the `tm list` CLI command
-
-- outputs tasks in a minimal, git-style one-line format. This reduces verbose output from ~30+ lines of dashboards and tables to just 1 line per task, making it much easier to quickly scan available tasks.
-  - Git-style format: ID STATUS TITLE (PRIORITY) → DEPS
-  - Color-coded status, priority, and dependencies
-  - Smart title truncation and dependency abbreviation
-  - Subtask support with indentation
-  - Full backward compatibility with existing list options

.changeset/floppy-starts-find.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add CLI & MCP progress tracking for parse-prd command.

.changeset/light-crabs-warn.md

@@ -1,5 +0,0 @@
----
-"extension": minor
----
-
-Display current task ID on task details page

.changeset/rude-moments-search.md

@@ -1,7 +0,0 @@
----
-"task-master-ai": patch
----
-
-Fix `add-tag --from-branch` command error where `projectRoot` was not properly referenced
-
-The command was failing with "projectRoot is not defined" error because the code was directly referencing `projectRoot` instead of `context.projectRoot` in the git repository checks. This fix corrects the variable references to use the proper context object.

.changeset/slow-readers-deny.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add support for ollama `gpt-oss:20b` and `gpt-oss:120b`

.changeset/wet-seas-float.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Remove `clear` Taskmaster claude code commands since they were too close to the claude-code clear command

.claude/commands/dedupe.md

@@ -33,6 +33,6 @@ This issue will be automatically closed as a duplicate in 3 days.
 - If your issue is a duplicate, please close it and 👍 the existing issue instead
 - To prevent auto-closure, add a comment or 👎 this comment
 
-🤖 Generated with [Claude Code](https://claude.ai/code)
+🤖 Generated with \[Task Master Bot\]
 
 ---

.claude/commands/tm/remove-subtasks/remove-all-subtasks.md

@@ -0,0 +1,93 @@
+Clear all subtasks from all tasks globally.
+
+## Global Subtask Clearing
+
+Remove all subtasks across the entire project. Use with extreme caution.
+
+## Execution
+
+```bash
+task-master clear-subtasks --all
+```
+
+## Pre-Clear Analysis
+
+1. **Project-Wide Summary**
+   ```
+   Global Subtask Summary
+   ━━━━━━━━━━━━━━━━━━━━
+   Total parent tasks: 12
+   Total subtasks: 47
+   - Completed: 15
+   - In-progress: 8
+   - Pending: 24
+   
+   Work at risk: ~120 hours
+   ```
+
+2. **Critical Warnings**
+   - In-progress subtasks that will lose work
+   - Completed subtasks with valuable history
+   - Complex dependency chains
+   - Integration test results
+
+## Double Confirmation
+
+```
+⚠️  DESTRUCTIVE OPERATION WARNING ⚠️
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+This will remove ALL 47 subtasks from your project
+Including 8 in-progress and 15 completed subtasks
+
+This action CANNOT be undone
+
+Type 'CLEAR ALL SUBTASKS' to confirm:
+```
+
+## Smart Safeguards
+
+- Require explicit confirmation phrase
+- Create automatic backup
+- Log all removed data
+- Option to export first
+
+## Use Cases
+
+Valid reasons for global clear:
+- Project restructuring
+- Major pivot in approach
+- Starting fresh breakdown
+- Switching to different task organization
+
+## Process
+
+1. Full project analysis
+2. Create backup file
+3. Show detailed impact
+4. Require confirmation
+5. Execute removal
+6. Generate summary report
+
+## Alternative Suggestions
+
+Before clearing all:
+- Export subtasks to file
+- Clear only pending subtasks
+- Clear by task category
+- Archive instead of delete
+
+## Post-Clear Report
+
+```
+Global Subtask Clear Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Removed: 47 subtasks from 12 tasks
+Backup saved: .taskmaster/backup/subtasks-20240115.json
+Parent tasks updated: 12
+Time estimates adjusted: Yes
+
+Next steps:
+- Review updated task list
+- Re-expand complex tasks as needed
+- Check project timeline
+```

.claude/commands/tm/remove-subtasks/remove-subtasks.md

@@ -0,0 +1,86 @@
+Clear all subtasks from a specific task.
+
+Arguments: $ARGUMENTS (task ID)
+
+Remove all subtasks from a parent task at once.
+
+## Clearing Subtasks
+
+Bulk removal of all subtasks from a parent task.
+
+## Execution
+
+```bash
+task-master clear-subtasks --id=<task-id>
+```
+
+## Pre-Clear Analysis
+
+1. **Subtask Summary**
+   - Number of subtasks
+   - Completion status of each
+   - Work already done
+   - Dependencies affected
+
+2. **Impact Assessment**
+   - Data that will be lost
+   - Dependencies to be removed
+   - Effect on project timeline
+   - Parent task implications
+
+## Confirmation Required
+
+```
+Clear Subtasks Confirmation
+━━━━━━━━━━━━━━━━━━━━━━━━━
+Parent Task: #5 "Implement user authentication"
+Subtasks to remove: 4
+- #5.1 "Setup auth framework" (done)
+- #5.2 "Create login form" (in-progress)
+- #5.3 "Add validation" (pending)
+- #5.4 "Write tests" (pending)
+
+⚠️  This will permanently delete all subtask data
+Continue? (y/n)
+```
+
+## Smart Features
+
+- Option to convert to standalone tasks
+- Backup task data before clearing
+- Preserve completed work history
+- Update parent task appropriately
+
+## Process
+
+1. List all subtasks for confirmation
+2. Check for in-progress work
+3. Remove all subtasks
+4. Update parent task
+5. Clean up dependencies
+
+## Alternative Options
+
+Suggest alternatives:
+- Convert important subtasks to tasks
+- Keep completed subtasks
+- Archive instead of delete
+- Export subtask data first
+
+## Post-Clear
+
+- Show updated parent task
+- Recalculate time estimates
+- Update task complexity
+- Suggest next steps
+
+## Example
+
+```
+/project:tm/clear-subtasks 5
+→ Found 4 subtasks to remove
+→ Warning: Subtask #5.2 is in-progress
+→ Cleared all subtasks from task #5
+→ Updated parent task estimates
+→ Suggestion: Consider re-expanding with better breakdown
+```

.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/ci.yml

@@ -9,70 +9,124 @@ on:
     branches:
       - main
       - next
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 permissions:
   contents: read
 
+env:
+  DO_NOT_TRACK: 1
+  NODE_ENV: development
+
 jobs:
-  setup:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: 'npm'
-
-      - name: Install Dependencies
-        id: install
-        run: npm ci
-        timeout-minutes: 2
-
-      - name: Cache node_modules
-        uses: actions/cache@v4
-        with:
-          path: node_modules
-          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
-
+  # Fast checks that can run in parallel
   format-check:
-    needs: setup
+    name: Format Check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
 
       - uses: actions/setup-node@v4
         with:
           node-version: 20
+          cache: "npm"
 
-      - name: Restore node_modules
-        uses: actions/cache@v4
-        with:
-          path: node_modules
-          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
+      - name: Install dependencies
+        run: npm install --frozen-lockfile --prefer-offline
+        timeout-minutes: 5
 
       - name: Format Check
         run: npm run format-check
         env:
           FORCE_COLOR: 1
 
-  test:
-    needs: setup
+  typecheck:
+    name: Typecheck
+    timeout-minutes: 10
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
 
       - uses: actions/setup-node@v4
         with:
           node-version: 20
+          cache: "npm"
 
-      - name: Restore node_modules
-        uses: actions/cache@v4
+      - name: Install dependencies
+        run: npm install --frozen-lockfile --prefer-offline
+        timeout-minutes: 5
+
+      - name: Typecheck
+        run: npm run turbo:typecheck
+        env:
+          FORCE_COLOR: 1
+
+  # Build job to ensure everything compiles
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
         with:
-          path: node_modules
-          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
+          fetch-depth: 2
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm install --frozen-lockfile --prefer-offline
+        timeout-minutes: 5
+
+      - name: Build
+        run: npm run turbo:build
+        env:
+          NODE_ENV: production
+          FORCE_COLOR: 1
+          TM_PUBLIC_BASE_DOMAIN: ${{ secrets.TM_PUBLIC_BASE_DOMAIN }}
+          TM_PUBLIC_SUPABASE_URL: ${{ secrets.TM_PUBLIC_SUPABASE_URL }}
+          TM_PUBLIC_SUPABASE_ANON_KEY: ${{ secrets.TM_PUBLIC_SUPABASE_ANON_KEY }}
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-artifacts
+          path: dist/
+          retention-days: 1
+
+  test:
+    name: Test
+    timeout-minutes: 15
+    runs-on: ubuntu-latest
+    needs: [format-check, typecheck, build]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm install --frozen-lockfile --prefer-offline
+        timeout-minutes: 5
+
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: build-artifacts
+          path: dist/
 
       - name: Run Tests
         run: |
@@ -81,7 +135,6 @@ jobs:
           NODE_ENV: test
           CI: true
           FORCE_COLOR: 1
-        timeout-minutes: 10
 
       - name: Upload Test Results
         if: always()

.github/workflows/claude-docs-trigger.yml

@@ -0,0 +1,57 @@
+name: Trigger Claude Documentation Update
+
+on:
+  push:
+    branches:
+      - next
+    paths-ignore:
+      - "apps/docs/**"
+      - "*.md"
+      - ".github/workflows/**"
+
+jobs:
+  trigger-docs-update:
+    # Only run if changes were merged (not direct pushes from bots)
+    if: github.actor != 'github-actions[bot]' && github.actor != 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      actions: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2 # Need previous commit for comparison
+
+      - name: Get changed files
+        id: changed-files
+        run: |
+          echo "Changed files in this push:"
+          git diff --name-only HEAD^ HEAD | tee changed_files.txt
+
+          # Store changed files for Claude to analyze (escaped for JSON)
+          CHANGED_FILES=$(git diff --name-only HEAD^ HEAD | jq -Rs .)
+          echo "changed_files=$CHANGED_FILES" >> $GITHUB_OUTPUT
+
+          # Get the commit message (escaped for JSON)
+          COMMIT_MSG=$(git log -1 --pretty=%B | jq -Rs .)
+          echo "commit_message=$COMMIT_MSG" >> $GITHUB_OUTPUT
+
+          # Get diff for documentation context (escaped for JSON)
+          COMMIT_DIFF=$(git diff HEAD^ HEAD --stat | jq -Rs .)
+          echo "commit_diff=$COMMIT_DIFF" >> $GITHUB_OUTPUT
+
+          # Get commit SHA
+          echo "commit_sha=${{ github.sha }}" >> $GITHUB_OUTPUT
+
+      - name: Trigger Claude workflow
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Trigger the Claude docs updater workflow with the change information
+          gh workflow run claude-docs-updater.yml \
+            --ref next \
+            -f commit_sha="${{ steps.changed-files.outputs.commit_sha }}" \
+            -f commit_message=${{ steps.changed-files.outputs.commit_message }} \
+            -f changed_files=${{ steps.changed-files.outputs.changed_files }} \
+            -f commit_diff=${{ steps.changed-files.outputs.commit_diff }}

.github/workflows/claude-docs-updater.yml

@@ -1,50 +1,38 @@
 name: Claude Documentation Updater
 
 on:
-  push:
-    branches:
-      - next
-    paths-ignore:
-      - 'apps/docs/**'
-      - '*.md'
-      - '.github/workflows/**'
+  workflow_dispatch:
+    inputs:
+      commit_sha:
+        description: 'The commit SHA that triggered this update'
+        required: true
+        type: string
+      commit_message:
+        description: 'The commit message'
+        required: true
+        type: string
+      changed_files:
+        description: 'List of changed files'
+        required: true
+        type: string
+      commit_diff:
+        description: 'Diff summary of changes'
+        required: true
+        type: string
 
 jobs:
   update-docs:
-    # Only run if changes were merged (not direct pushes from bots)
-    if: github.event.pusher.name != 'github-actions[bot]' && github.event.pusher.name != 'dependabot[bot]'
     runs-on: ubuntu-latest
     permissions:
       contents: write
       pull-requests: write
       issues: write
-      id-token: write
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
-          fetch-depth: 2  # Need previous commit for comparison
-
-      - name: Get changed files
-        id: changed-files
-        run: |
-          echo "Changed files in this push:"
-          git diff --name-only HEAD^ HEAD | tee changed_files.txt
-          
-          # Store changed files for Claude to analyze
-          echo "changed_files<<EOF" >> $GITHUB_OUTPUT
-          git diff --name-only HEAD^ HEAD >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-          
-          # Get the commit message and changes summary
-          echo "commit_message<<EOF" >> $GITHUB_OUTPUT
-          git log -1 --pretty=%B >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-          
-          # Get diff for documentation context
-          echo "commit_diff<<EOF" >> $GITHUB_OUTPUT
-          git diff HEAD^ HEAD --stat >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
+          ref: next
+          fetch-depth: 0 # Need full history to checkout specific commit
 
       - name: Create docs update branch
         id: create-branch
@@ -58,23 +46,26 @@ jobs:
         with:
           anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
           timeout_minutes: "30"
-          mode: "auto"
+          mode: "agent"
+          github_token: ${{ secrets.GITHUB_TOKEN }}
           experimental_allowed_domains: |
             .anthropic.com
             .github.com
             api.github.com
             .githubusercontent.com
             registry.npmjs.org
-          prompt: |
+            .task-master.dev
+          base_branch: "next"
+          direct_prompt: |
             You are a documentation specialist. Analyze the recent changes pushed to the 'next' branch and update the documentation accordingly.
 
             Recent changes:
-            - Commit: ${{ steps.changed-files.outputs.commit_message }}
+            - Commit: ${{ inputs.commit_message }}
             - Changed files:
-            ${{ steps.changed-files.outputs.changed_files }}
+            ${{ inputs.changed_files }}
 
             - Changes summary:
-            ${{ steps.changed-files.outputs.commit_diff }}
+            ${{ inputs.commit_diff }}
 
             Your task:
             1. Analyze the changes to understand what functionality was added, modified, or removed
@@ -111,7 +102,7 @@ jobs:
 
             This PR was automatically generated to update documentation based on recent changes.
             
-            Original commit: ${{ steps.changed-files.outputs.commit_message }}
+            Original commit: ${{ inputs.commit_message }}
             
             Co-authored-by: Claude <claude-assistant@anthropic.com>"
           fi
@@ -131,12 +122,12 @@ jobs:
             This PR automatically updates documentation based on recent changes merged to the \`next\` branch.
 
             ### Original Changes
-            **Commit:** ${{ github.sha }}
-            **Message:** ${{ steps.changed-files.outputs.commit_message }}
+            **Commit:** ${{ inputs.commit_sha }}
+            **Message:** ${{ inputs.commit_message }}
             
             ### Changed Files in Original Commit
             \`\`\`
-            ${{ steps.changed-files.outputs.changed_files }}
+            ${{ inputs.changed_files }}
             \`\`\`
 
             ### Documentation Updates

.github/workflows/pre-release.yml

@@ -65,6 +65,20 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
+      - name: Run format
+        run: npm run format
+        env:
+          FORCE_COLOR: 1
+
+      - name: Build packages
+        run: npm run turbo:build
+        env:
+          NODE_ENV: production
+          FORCE_COLOR: 1
+          TM_PUBLIC_BASE_DOMAIN: ${{ secrets.TM_PUBLIC_BASE_DOMAIN }}
+          TM_PUBLIC_SUPABASE_URL: ${{ secrets.TM_PUBLIC_SUPABASE_URL }}
+          TM_PUBLIC_SUPABASE_ANON_KEY: ${{ secrets.TM_PUBLIC_SUPABASE_ANON_KEY }}
+
       - name: Create Release Candidate Pull Request or Publish Release Candidate to npm
         uses: changesets/action@v1
         with:

.github/workflows/release.yml

@@ -22,7 +22,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: 'npm'
+          cache: "npm"
 
       - name: Cache node_modules
         uses: actions/cache@v4
@@ -41,6 +41,15 @@ jobs:
       - name: Check pre-release mode
         run: node ./.github/scripts/check-pre-release-mode.mjs "main"
 
+      - name: Build packages
+        run: npm run turbo:build
+        env:
+          NODE_ENV: production
+          FORCE_COLOR: 1
+          TM_PUBLIC_BASE_DOMAIN: ${{ secrets.TM_PUBLIC_BASE_DOMAIN }}
+          TM_PUBLIC_SUPABASE_URL: ${{ secrets.TM_PUBLIC_SUPABASE_URL }}
+          TM_PUBLIC_SUPABASE_ANON_KEY: ${{ secrets.TM_PUBLIC_SUPABASE_ANON_KEY }}
+
       - name: Create Release Pull Request or Publish to npm
         uses: changesets/action@v1
         with:

.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 }}
+            • Avg Response Time: ${{ steps.metrics.outputs.pr_avg_first_response }}
+            • Avg Time to Merge: ${{ steps.metrics.outputs.pr_avg_merge_time }}
 
-            **⏱️ 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 }}
+            **📈 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

.gitignore

@@ -94,3 +94,6 @@ apps/extension/.vscode-test/
 
 # apps/extension
 apps/extension/vsix-build/
+
+# turbo
+.turbo

.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",

.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/MIGRATION-ROADMAP.md

@@ -0,0 +1,188 @@
+# Task Master Migration Roadmap
+
+## Overview
+Gradual migration from scripts-based architecture to a clean monorepo with separated concerns.
+
+## Architecture Vision
+
+```
+┌─────────────────────────────────────────────────┐
+│                  User Interfaces                 │
+├──────────┬──────────┬──────────┬────────────────┤
+│  @tm/cli │ @tm/mcp  │ @tm/ext  │  @tm/web      │
+│  (CLI)   │  (MCP)   │  (VSCode)│  (Future)     │
+└──────────┴──────────┴──────────┴────────────────┘
+                    │
+                    ▼
+        ┌──────────────────────┐
+        │      @tm/core        │
+        │  (Business Logic)    │
+        └──────────────────────┘
+```
+
+## Migration Phases
+
+### Phase 1: Core Extraction ✅ (In Progress)
+**Goal**: Move all business logic to @tm/core
+
+- [x] Create @tm/core package structure
+- [x] Move types and interfaces
+- [x] Implement TaskMasterCore facade
+- [x] Move storage adapters
+- [x] Move task services
+- [ ] Move AI providers
+- [ ] Move parser logic
+- [ ] Complete test coverage
+
+### Phase 2: CLI Package Creation 🚧 (Started)
+**Goal**: Create @tm/cli as a thin presentation layer
+
+- [x] Create @tm/cli package structure
+- [x] Implement Command interface pattern
+- [x] Create CommandRegistry
+- [x] Build legacy bridge/adapter
+- [x] Migrate list-tasks command
+- [ ] Migrate remaining commands one by one
+- [ ] Remove UI logic from core
+
+### Phase 3: Transitional Integration
+**Goal**: Use new packages in existing scripts without breaking changes
+
+```javascript
+// scripts/modules/commands.js gradually adopts new commands
+import { ListTasksCommand } from '@tm/cli';
+const listCommand = new ListTasksCommand();
+
+// Old interface remains the same
+programInstance
+  .command('list')
+  .action(async (options) => {
+    // Use new command internally
+    const result = await listCommand.execute(convertOptions(options));
+  });
+```
+
+### Phase 4: MCP Package
+**Goal**: Separate MCP server as its own package
+
+- [ ] Create @tm/mcp package
+- [ ] Move MCP server code
+- [ ] Use @tm/core for all logic
+- [ ] MCP becomes a thin RPC layer
+
+### Phase 5: Complete Migration
+**Goal**: Remove old scripts, pure monorepo
+
+- [ ] All commands migrated to @tm/cli
+- [ ] Remove scripts/modules/task-manager/*
+- [ ] Remove scripts/modules/commands.js
+- [ ] Update bin/task-master.js to use @tm/cli
+- [ ] Clean up dependencies
+
+## Current Transitional Strategy
+
+### 1. Adapter Pattern (commands-adapter.js)
+```javascript
+// Checks if new CLI is available and uses it
+// Falls back to legacy implementation if not
+export async function listTasksAdapter(...args) {
+  if (cliAvailable) {
+    return useNewImplementation(...args);
+  }
+  return useLegacyImplementation(...args);
+}
+```
+
+### 2. Command Bridge Pattern
+```javascript
+// Allows new commands to work in old code
+const bridge = new CommandBridge(new ListTasksCommand());
+const data = await bridge.run(legacyOptions); // Legacy style
+const result = await bridge.execute(newOptions); // New style
+```
+
+### 3. Gradual File Migration
+Instead of big-bang refactoring:
+1. Create new implementation in @tm/cli
+2. Add adapter in commands-adapter.js
+3. Update commands.js to use adapter
+4. Test both paths work
+5. Eventually remove adapter when all migrated
+
+## Benefits of This Approach
+
+1. **No Breaking Changes**: Existing CLI continues to work
+2. **Incremental PRs**: Each command can be migrated separately
+3. **Parallel Development**: New features can use new architecture
+4. **Easy Rollback**: Can disable new implementation if issues
+5. **Clear Separation**: Business logic (core) vs presentation (cli/mcp/etc)
+
+## Example PR Sequence
+
+### PR 1: Core Package Setup ✅
+- Create @tm/core
+- Move types and interfaces
+- Basic TaskMasterCore implementation
+
+### PR 2: CLI Package Foundation ✅
+- Create @tm/cli
+- Command interface and registry
+- Legacy bridge utilities
+
+### PR 3: First Command Migration
+- Migrate list-tasks to new system
+- Add adapter in scripts
+- Test both implementations
+
+### PR 4-N: Migrate Commands One by One
+- Each PR migrates 1-2 related commands
+- Small, reviewable changes
+- Continuous delivery
+
+### Final PR: Cleanup
+- Remove legacy implementations
+- Remove adapters
+- Update documentation
+
+## Testing Strategy
+
+### Dual Testing During Migration
+```javascript
+describe('List Tasks', () => {
+  it('works with legacy implementation', async () => {
+    // Force legacy
+    const result = await legacyListTasks(...);
+    expect(result).toBeDefined();
+  });
+
+  it('works with new implementation', async () => {
+    // Force new
+    const command = new ListTasksCommand();
+    const result = await command.execute(...);
+    expect(result.success).toBe(true);
+  });
+
+  it('adapter chooses correctly', async () => {
+    // Let adapter decide
+    const result = await listTasksAdapter(...);
+    expect(result).toBeDefined();
+  });
+});
+```
+
+## Success Metrics
+
+- [ ] All commands migrated without breaking changes
+- [ ] Test coverage maintained or improved
+- [ ] Performance maintained or improved
+- [ ] Cleaner, more maintainable codebase
+- [ ] Easy to add new interfaces (web, desktop, etc.)
+
+## Notes for Contributors
+
+1. **Keep PRs Small**: Migrate one command at a time
+2. **Test Both Paths**: Ensure legacy and new both work
+3. **Document Changes**: Update this roadmap as you go
+4. **Communicate**: Discuss in PRs if architecture needs adjustment
+
+This is a living document - update as the migration progresses!

.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/reports/task-complexity-report_tm-core-phase-1.json

@@ -0,0 +1,77 @@
+{
+	"meta": {
+		"generatedAt": "2025-08-06T12:39:03.250Z",
+		"tasksAnalyzed": 8,
+		"totalTasks": 11,
+		"analysisCount": 8,
+		"thresholdScore": 5,
+		"projectName": "Taskmaster",
+		"usedResearch": false
+	},
+	"complexityAnalysis": [
+		{
+			"taskId": 118,
+			"taskTitle": "Create AI Provider Base Architecture",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Break down the implementation of BaseProvider abstract TypeScript class into subtasks focusing on: 1) Converting existing JavaScript base-provider.js to TypeScript with proper interface definitions, 2) Implementing the Template Method pattern with abstract methods, 3) Adding comprehensive error handling and retry logic with exponential backoff, 4) Creating proper TypeScript types for all method signatures and options, 5) Setting up comprehensive unit tests with MockProvider. Consider that the existing codebase uses JavaScript ES modules and Vercel AI SDK, so the TypeScript implementation needs to maintain compatibility while adding type safety.",
+			"reasoning": "This task requires significant architectural work including converting existing JavaScript code to TypeScript, creating new interfaces, implementing design patterns, and ensuring backward compatibility. The existing base-provider.js already implements a sophisticated provider pattern using Vercel AI SDK, so the TypeScript conversion needs careful consideration of type definitions and maintaining existing functionality."
+		},
+		{
+			"taskId": 119,
+			"taskTitle": "Implement Provider Factory with Dynamic Imports",
+			"complexityScore": 5,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Break down the Provider Factory implementation into: 1) Creating the ProviderFactory class structure with proper TypeScript typing, 2) Implementing the switch statement for provider selection logic, 3) Adding dynamic imports for each provider to enable tree-shaking, 4) Handling provider instantiation with configuration passing, 5) Implementing comprehensive error handling for module loading failures. Note that the existing codebase already has a provider selection mechanism in the JavaScript files, so ensure the factory pattern integrates smoothly with existing infrastructure.",
+			"reasoning": "This is a moderate complexity task that involves creating a factory pattern with dynamic imports. The existing codebase already has provider management logic, so the main complexity is in creating a clean TypeScript implementation with proper dynamic imports while maintaining compatibility with the existing JavaScript module system."
+		},
+		{
+			"taskId": 120,
+			"taskTitle": "Implement Anthropic Provider",
+			"complexityScore": 6,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Implement the AnthropicProvider class in stages: 1) Set up the class structure extending BaseProvider with proper TypeScript imports and type definitions, 2) Implement constructor with Anthropic SDK client initialization and configuration handling, 3) Implement generateCompletion method with proper message format transformation and error handling, 4) Add token calculation methods and utility functions (getName, getModel, getDefaultModel), 5) Implement comprehensive error handling with custom error wrapping and type exports. The existing anthropic.js provider can serve as a reference but needs to be reimplemented to extend the new TypeScript BaseProvider.",
+			"reasoning": "This task involves integrating with an external SDK (@anthropic-ai/sdk) and implementing all abstract methods from BaseProvider. The existing JavaScript implementation provides a good reference, but the TypeScript version needs proper type definitions, error handling, and must work with the new abstract base class architecture."
+		},
+		{
+			"taskId": 121,
+			"taskTitle": "Create Prompt Builder and Task Parser",
+			"complexityScore": 8,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Implement PromptBuilder and TaskParser with focus on: 1) Creating PromptBuilder class with template methods for building structured prompts with JSON format instructions, 2) Implementing TaskParser class structure with dependency injection of IAIProvider and IConfiguration, 3) Implementing parsePRD method with file reading, prompt generation, and AI provider integration, 4) Adding task enrichment logic with metadata, validation, and structure verification, 5) Implementing comprehensive error handling for all failure scenarios including file I/O, AI provider errors, and JSON parsing. The existing parse-prd.js provides complex logic that needs to be reimplemented with proper TypeScript types and cleaner architecture.",
+			"reasoning": "This is a complex task that involves multiple components working together: file I/O, AI provider integration, JSON parsing, and data validation. The existing parse-prd.js implementation is quite sophisticated with Zod schemas and complex task processing logic that needs to be reimplemented in TypeScript with proper separation of concerns."
+		},
+		{
+			"taskId": 122,
+			"taskTitle": "Implement Configuration Management",
+			"complexityScore": 6,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Create ConfigManager implementation focusing on: 1) Setting up Zod validation schema that matches the IConfiguration interface structure, 2) Implementing ConfigManager constructor with default values merging and storage initialization, 3) Creating validate method with Zod schema parsing and user-friendly error transformation, 4) Implementing type-safe get method using TypeScript generics and keyof operator, 5) Adding getAll method and ensuring proper immutability and module exports. The existing config-manager.js has complex configuration loading logic that can inform the TypeScript implementation but needs cleaner architecture.",
+			"reasoning": "This task involves creating a configuration management system with validation using Zod. The existing JavaScript config-manager.js is quite complex with multiple configuration sources, defaults, and validation logic. The TypeScript version needs to provide a cleaner API while maintaining the flexibility of the current system."
+		},
+		{
+			"taskId": 123,
+			"taskTitle": "Create Utility Functions and Error Handling",
+			"complexityScore": 4,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Implement utilities and error handling in stages: 1) Create ID generation module with generateTaskId and generateSubtaskId functions using proper random generation, 2) Implement base TaskMasterError class extending Error with proper TypeScript typing, 3) Add error sanitization methods to prevent sensitive data exposure in production, 4) Implement development-only logging with environment detection, 5) Create specialized error subclasses (FileNotFoundError, ParseError, ValidationError, APIError) with appropriate error codes and formatting.",
+			"reasoning": "This is a relatively straightforward task involving utility functions and error class hierarchies. The main complexity is in ensuring proper error sanitization for production use and creating a well-structured error hierarchy that can be used throughout the application."
+		},
+		{
+			"taskId": 124,
+			"taskTitle": "Implement TaskMasterCore Facade",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Build TaskMasterCore facade implementation: 1) Create class structure with proper TypeScript imports and type definitions for all subsystem interfaces, 2) Implement initialize method for lazy loading AI provider and parser instances based on configuration, 3) Create parsePRD method that coordinates parser, AI provider, and storage subsystems, 4) Implement getTasks and other facade methods for task retrieval and management, 5) Create createTaskMaster factory function and set up all module exports including type re-exports. Ensure proper ESM compatibility with .js extensions in imports.",
+			"reasoning": "This is a complex integration task that brings together all the other components into a cohesive facade. It requires understanding of the facade pattern, proper dependency management, lazy initialization, and careful module export structure for the public API."
+		},
+		{
+			"taskId": 125,
+			"taskTitle": "Create Placeholder Providers and Complete Testing",
+			"complexityScore": 5,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Complete the implementation with placeholders and testing: 1) Create OpenAIProvider placeholder class extending BaseProvider with 'not yet implemented' errors, 2) Create GoogleProvider placeholder class with similar structure, 3) Implement MockProvider in tests/mocks directory with configurable responses and behavior simulation, 4) Write comprehensive unit tests for TaskParser covering all methods and edge cases, 5) Create integration tests for the complete parse-prd workflow ensuring 80% code coverage. Follow kebab-case naming convention for test files.",
+			"reasoning": "This task involves creating placeholder implementations and a comprehensive test suite. While the placeholder providers are simple, creating a good MockProvider and comprehensive tests requires understanding the entire system architecture and ensuring all edge cases are covered."
+		}
+	]
+}

.taskmaster/reports/tm-core-complexity.json

@@ -0,0 +1,77 @@
+{
+	"meta": {
+		"generatedAt": "2025-08-06T12:15:01.327Z",
+		"tasksAnalyzed": 8,
+		"totalTasks": 11,
+		"analysisCount": 8,
+		"thresholdScore": 5,
+		"projectName": "Taskmaster",
+		"usedResearch": false
+	},
+	"complexityAnalysis": [
+		{
+			"taskId": 118,
+			"taskTitle": "Create AI Provider Base Architecture",
+			"complexityScore": 4,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Break down the conversion of base-provider.js to TypeScript BaseProvider class: 1) Convert to TypeScript and define IAIProvider interface, 2) Implement abstract class with core properties, 3) Define abstract methods and Template Method pattern, 4) Add retry logic with exponential backoff, 5) Implement validation and logging. Focus on maintaining compatibility with existing provider pattern while adding type safety.",
+			"reasoning": "The codebase already has a well-established BaseAIProvider class in JavaScript. Converting to TypeScript mainly involves adding type definitions and ensuring the existing pattern is preserved. The complexity is moderate because the pattern is already proven in the codebase."
+		},
+		{
+			"taskId": 119,
+			"taskTitle": "Implement Provider Factory with Dynamic Imports",
+			"complexityScore": 3,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Create ProviderFactory implementation: 1) Set up class structure and types, 2) Implement provider selection switch statement, 3) Add dynamic imports for tree-shaking, 4) Handle provider instantiation with config, 5) Add comprehensive error handling. The existing PROVIDERS registry pattern should guide the implementation.",
+			"reasoning": "The codebase already uses a dual registry pattern (static PROVIDERS and dynamic ProviderRegistry). Creating a factory is straightforward as the provider registration patterns are well-established. Dynamic imports are already used in the codebase."
+		},
+		{
+			"taskId": 120,
+			"taskTitle": "Implement Anthropic Provider",
+			"complexityScore": 3,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Implement AnthropicProvider following existing patterns: 1) Create class structure with imports, 2) Implement constructor and client initialization, 3) Add generateCompletion with Claude API integration, 4) Implement token calculation and utility methods, 5) Add error handling and exports. Use the existing anthropic.js provider as reference.",
+			"reasoning": "AnthropicProvider already exists in the codebase with full implementation. This task essentially involves adapting the existing implementation to match the new TypeScript architecture, making it relatively straightforward."
+		},
+		{
+			"taskId": 121,
+			"taskTitle": "Create Prompt Builder and Task Parser",
+			"complexityScore": 6,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Build prompt system and parser: 1) Create PromptBuilder with template methods, 2) Implement TaskParser with dependency injection, 3) Add parsePRD core logic with file reading, 4) Implement task enrichment and metadata, 5) Add comprehensive error handling. Leverage the existing prompt management system in src/prompts/.",
+			"reasoning": "While the codebase has a sophisticated prompt management system, creating a new PromptBuilder and TaskParser requires understanding the existing prompt templates, JSON schema validation, and integration with the AI provider system. The task involves significant new code."
+		},
+		{
+			"taskId": 122,
+			"taskTitle": "Implement Configuration Management",
+			"complexityScore": 5,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Create ConfigManager with validation: 1) Define Zod schema for IConfiguration, 2) Implement constructor with defaults, 3) Add validate method with error handling, 4) Create type-safe get method with generics, 5) Implement getAll and finalize exports. Reference existing config-manager.js for patterns.",
+			"reasoning": "The codebase has an existing config-manager.js with sophisticated configuration handling. Adding Zod validation and TypeScript generics adds complexity, but the existing patterns provide a solid foundation."
+		},
+		{
+			"taskId": 123,
+			"taskTitle": "Create Utility Functions and Error Handling",
+			"complexityScore": 2,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Implement utilities and error handling: 1) Create ID generation module with unique formats, 2) Build TaskMasterError base class, 3) Add error sanitization for security, 4) Implement development-only logging, 5) Create specialized error subclasses. Keep implementation simple and focused.",
+			"reasoning": "This is a straightforward utility implementation task. The codebase already has error handling patterns, and ID generation is a simple algorithmic task. The main work is creating clean, reusable utilities."
+		},
+		{
+			"taskId": 124,
+			"taskTitle": "Implement TaskMasterCore Facade",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Create main facade class: 1) Set up TaskMasterCore structure with imports, 2) Implement lazy initialization logic, 3) Add parsePRD coordination method, 4) Implement getTasks and other facade methods, 5) Create factory function and exports. This ties together all other components into a cohesive API.",
+			"reasoning": "This is the most complex task as it requires understanding and integrating all other components. The facade must coordinate between configuration, providers, storage, and parsing while maintaining a clean API. It's the architectural keystone of the system."
+		},
+		{
+			"taskId": 125,
+			"taskTitle": "Create Placeholder Providers and Complete Testing",
+			"complexityScore": 5,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Implement testing infrastructure: 1) Create OpenAIProvider placeholder, 2) Create GoogleProvider placeholder, 3) Build MockProvider for testing, 4) Write TaskParser unit tests, 5) Create integration tests for parse-prd flow. Follow the existing test patterns in tests/ directory.",
+			"reasoning": "While creating placeholder providers is simple, the testing infrastructure requires understanding Jest with ES modules, mocking patterns, and comprehensive test coverage. The existing test structure provides good examples to follow."
+		}
+	]
+}

.taskmaster/state.json

@@ -1,6 +1,6 @@
 {
 	"currentTag": "master",
-	"lastSwitched": "2025-08-01T14:09:25.838Z",
+	"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.

.vscode/settings.json

@@ -10,5 +10,18 @@
 	},
 
 	"json.format.enable": true,
-	"json.validate.enable": true
+	"json.validate.enable": true,
+	"typescript.tsdk": "node_modules/typescript/lib",
+	"[typescript]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[typescriptreact]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[javascript]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	},
+	"[json]": {
+		"editor.defaultFormatter": "biomejs.biome"
+	}
 }

CHANGELOG.md

@@ -1,5 +1,318 @@
 # task-master-ai
 
+## 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
+
+- [`255b9f0`](https://github.com/eyaltoledano/claude-task-master/commit/255b9f0334555b0063280abde701445cd62fa11b) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Testing one more pre-release iteration
+
+## 0.27.0-rc.0
+
+### Minor Changes
+
+- [#1213](https://github.com/eyaltoledano/claude-task-master/pull/1213) [`137ef36`](https://github.com/eyaltoledano/claude-task-master/commit/137ef362789a9cdfdb1925e35e0438c1fa6c69ee) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Test out the RC
+
+### Patch Changes
+
+- Updated dependencies [[`137ef36`](https://github.com/eyaltoledano/claude-task-master/commit/137ef362789a9cdfdb1925e35e0438c1fa6c69ee)]:
+  - @tm/cli@0.27.0-rc.0
+
+## 0.26.0
+
+### Minor Changes
+
+- [#1133](https://github.com/eyaltoledano/claude-task-master/pull/1133) [`df26c65`](https://github.com/eyaltoledano/claude-task-master/commit/df26c65632000874a73504963b08f18c46283144) Thanks [@neonwatty](https://github.com/neonwatty)! - Restore Taskmaster claude-code commands and move clear commands under /remove to avoid collision with the claude-code /clear command.
+
+- [#1163](https://github.com/eyaltoledano/claude-task-master/pull/1163) [`37af0f1`](https://github.com/eyaltoledano/claude-task-master/commit/37af0f191227a68d119b7f89a377bf932ee3ac66) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Enhanced Gemini CLI provider with codebase-aware task generation
+
+  Added automatic codebase analysis for Gemini CLI provider in parse-prd, and analyze-complexity, add-task, udpate-task, update, update-subtask commands
+  When using Gemini CLI as the AI provider, Task Master now instructs the AI to analyze the project structure, existing implementations, and patterns before generating tasks or subtasks
+  Tasks and subtasks generated by Claude Code are now informed by actual codebase analysis, resulting in more accurate and contextual outputs
+
+- [#1165](https://github.com/eyaltoledano/claude-task-master/pull/1165) [`c4f92f6`](https://github.com/eyaltoledano/claude-task-master/commit/c4f92f6a0aee3435c56eb8d27d9aa9204284833e) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add configurable codebase analysis feature flag with multiple configuration sources
+
+  Users can now control whether codebase analysis features (Claude Code and Gemini CLI integration) are enabled through environment variables, MCP configuration, or project config files.
+
+  Priority order: .env > MCP session env > .taskmaster/config.json.
+
+  Set `TASKMASTER_ENABLE_CODEBASE_ANALYSIS=false` in `.env` to disable codebase analysis prompts and tool integration.
+
+- [#1135](https://github.com/eyaltoledano/claude-task-master/pull/1135) [`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f) Thanks [@mm-parthy](https://github.com/mm-parthy)! - feat(move): improve cross-tag move UX and safety
+  - CLI: print "Next Steps" tips after cross-tag moves that used --ignore-dependencies (validate/fix guidance)
+  - CLI: show dedicated help block on ID collisions (destination tag already has the ID)
+  - Core: add structured suggestions to TASK_ALREADY_EXISTS errors
+  - MCP: map ID collision errors to TASK_ALREADY_EXISTS and include suggestions
+  - Tests: cover MCP options, error suggestions, CLI tips printing, and integration error payload suggestions
+
+  ***
+
+- [#1162](https://github.com/eyaltoledano/claude-task-master/pull/1162) [`4dad2fd`](https://github.com/eyaltoledano/claude-task-master/commit/4dad2fd613ceac56a65ae9d3c1c03092b8860ac9) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Enhanced Claude Code and Google CLI integration with automatic codebase analysis for task operations
+
+  When using Claude Code as the AI provider, task management commands now automatically analyze your codebase before generating or updating tasks. This provides more accurate, context-aware implementation details that align with your project's existing architecture and patterns.
+
+  Commands contextualised:
+  - add-task
+  - update-subtask
+  - update-task
+  - update
+
+### Patch Changes
+
+- [#1135](https://github.com/eyaltoledano/claude-task-master/pull/1135) [`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f) Thanks [@mm-parthy](https://github.com/mm-parthy)! - docs(move): clarify cross-tag move docs; deprecate "force"; add explicit --with-dependencies/--ignore-dependencies examples
+
+## 0.26.0-rc.1
+
+### Minor Changes
+
+- [#1165](https://github.com/eyaltoledano/claude-task-master/pull/1165) [`c4f92f6`](https://github.com/eyaltoledano/claude-task-master/commit/c4f92f6a0aee3435c56eb8d27d9aa9204284833e) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add configurable codebase analysis feature flag with multiple configuration sources
+
+  Users can now control whether codebase analysis features (Claude Code and Gemini CLI integration) are enabled through environment variables, MCP configuration, or project config files.
+
+  Priority order: .env > MCP session env > .taskmaster/config.json.
+
+  Set `TASKMASTER_ENABLE_CODEBASE_ANALYSIS=false` in `.env` to disable codebase analysis prompts and tool integration.
+
+## 0.26.0-rc.0
+
+### Minor Changes
+
+- [#1163](https://github.com/eyaltoledano/claude-task-master/pull/1163) [`37af0f1`](https://github.com/eyaltoledano/claude-task-master/commit/37af0f191227a68d119b7f89a377bf932ee3ac66) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Enhanced Gemini CLI provider with codebase-aware task generation
+
+  Added automatic codebase analysis for Gemini CLI provider in parse-prd, and analyze-complexity, add-task, udpate-task, update, update-subtask commands
+  When using Gemini CLI as the AI provider, Task Master now instructs the AI to analyze the project structure, existing implementations, and patterns before generating tasks or subtasks
+  Tasks and subtasks generated by Claude Code are now informed by actual codebase analysis, resulting in more accurate and contextual outputs
+
+- [#1135](https://github.com/eyaltoledano/claude-task-master/pull/1135) [`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f) Thanks [@mm-parthy](https://github.com/mm-parthy)! - feat(move): improve cross-tag move UX and safety
+  - CLI: print "Next Steps" tips after cross-tag moves that used --ignore-dependencies (validate/fix guidance)
+  - CLI: show dedicated help block on ID collisions (destination tag already has the ID)
+  - Core: add structured suggestions to TASK_ALREADY_EXISTS errors
+  - MCP: map ID collision errors to TASK_ALREADY_EXISTS and include suggestions
+  - Tests: cover MCP options, error suggestions, CLI tips printing, and integration error payload suggestions
+
+  ***
+
+- [#1162](https://github.com/eyaltoledano/claude-task-master/pull/1162) [`4dad2fd`](https://github.com/eyaltoledano/claude-task-master/commit/4dad2fd613ceac56a65ae9d3c1c03092b8860ac9) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Enhanced Claude Code and Google CLI integration with automatic codebase analysis for task operations
+
+  When using Claude Code as the AI provider, task management commands now automatically analyze your codebase before generating or updating tasks. This provides more accurate, context-aware implementation details that align with your project's existing architecture and patterns.
+
+  Commands contextualised:
+  - add-task
+  - update-subtask
+  - update-task
+  - update
+
+### Patch Changes
+
+- [#1135](https://github.com/eyaltoledano/claude-task-master/pull/1135) [`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f) Thanks [@mm-parthy](https://github.com/mm-parthy)! - docs(move): clarify cross-tag move docs; deprecate "force"; add explicit --with-dependencies/--ignore-dependencies examples
+
+## 0.25.1
+
+### Patch Changes
+
+- [#1152](https://github.com/eyaltoledano/claude-task-master/pull/1152) [`8933557`](https://github.com/eyaltoledano/claude-task-master/commit/89335578ffffc65504b2055c0c85aa7521e5e79b) Thanks [@ben-vargas](https://github.com/ben-vargas)! - fix(claude-code): prevent crash/hang when the optional `@anthropic-ai/claude-code` SDK is missing by guarding `AbortError instanceof` checks and adding explicit SDK presence checks in `doGenerate`/`doStream`. Also bump the optional dependency to `^1.0.88` for improved export consistency.
+
+  Related to JSON truncation handling in #920; this change addresses a separate error-path crash reported in #1142.
+
+- [#1151](https://github.com/eyaltoledano/claude-task-master/pull/1151) [`db720a9`](https://github.com/eyaltoledano/claude-task-master/commit/db720a954d390bb44838cd021b8813dde8f3d8de) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Temporarily disable streaming for improved model compatibility - will be re-enabled in upcoming release
+
+## 0.25.0
+
+### Minor Changes
+
+- [#1088](https://github.com/eyaltoledano/claude-task-master/pull/1088) [`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8) Thanks [@mm-parthy](https://github.com/mm-parthy)! - Add cross-tag task movement functionality for organizing tasks across different contexts.
+
+  This feature enables moving tasks between different tags (contexts) in your project, making it easier to organize work across different branches, environments, or project phases.
+
+  ## CLI Usage Examples
+
+  Move a single task from one tag to another:
+
+  ```bash
+  # Move task 5 from backlog tag to in-progress tag
+  task-master move --from=5 --from-tag=backlog --to-tag=feature-1
+
+  # Move task with its dependencies
+  task-master move --from=5 --from-tag=backlog --to-tag=feature-2 --with-dependencies
+
+  # Move task without checking dependencies
+  task-master move --from=5 --from-tag=backlog --to-tag=bug-3 --ignore-dependencies
+  ```
+
+  Move multiple tasks at once:
+
+  ```bash
+  # Move multiple tasks between tags
+  task-master move --from=5,6,7 --from-tag=backlog --to-tag=bug-4 --with-dependencies
+  ```
+
+- [#1040](https://github.com/eyaltoledano/claude-task-master/pull/1040) [`fc47714`](https://github.com/eyaltoledano/claude-task-master/commit/fc477143400fd11d953727bf1b4277af5ad308d1) Thanks [@DomVidja](https://github.com/DomVidja)! - "Add Kilo Code profile integration with custom modes and MCP configuration"
+
+- [#1054](https://github.com/eyaltoledano/claude-task-master/pull/1054) [`782728f`](https://github.com/eyaltoledano/claude-task-master/commit/782728ff95aa2e3b766d48273b57f6c6753e8573) Thanks [@martincik](https://github.com/martincik)! - Add compact mode --compact / -c flag to the `tm list` CLI command
+  - outputs tasks in a minimal, git-style one-line format. This reduces verbose output from ~30+ lines of dashboards and tables to just 1 line per task, making it much easier to quickly scan available tasks.
+    - Git-style format: ID STATUS TITLE (PRIORITY) → DEPS
+    - Color-coded status, priority, and dependencies
+    - Smart title truncation and dependency abbreviation
+    - Subtask support with indentation
+    - Full backward compatibility with existing list options
+
+- [#1048](https://github.com/eyaltoledano/claude-task-master/pull/1048) [`e3ed4d7`](https://github.com/eyaltoledano/claude-task-master/commit/e3ed4d7c14b56894d7da675eb2b757423bea8f9d) Thanks [@joedanz](https://github.com/joedanz)! - Add CLI & MCP progress tracking for parse-prd command.
+
+- [#1124](https://github.com/eyaltoledano/claude-task-master/pull/1124) [`95640dc`](https://github.com/eyaltoledano/claude-task-master/commit/95640dcde87ce7879858c0a951399fb49f3b6397) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add support for ollama `gpt-oss:20b` and `gpt-oss:120b`
+
+- [#1123](https://github.com/eyaltoledano/claude-task-master/pull/1123) [`311b243`](https://github.com/eyaltoledano/claude-task-master/commit/311b2433e23c771c8d3a4d3f5ac577302b8321e5) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Remove `clear` Taskmaster claude code commands since they were too close to the claude-code clear command
+
+### Patch Changes
+
+- [#1131](https://github.com/eyaltoledano/claude-task-master/pull/1131) [`3dee60d`](https://github.com/eyaltoledano/claude-task-master/commit/3dee60dc3d566e3cff650accb30f994b8bb3a15e) Thanks [@joedanz](https://github.com/joedanz)! - Update Cursor one-click install link to new URL format
+
+- [#1088](https://github.com/eyaltoledano/claude-task-master/pull/1088) [`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8) Thanks [@mm-parthy](https://github.com/mm-parthy)! - Fix `add-tag --from-branch` command error where `projectRoot` was not properly referenced
+
+  The command was failing with "projectRoot is not defined" error because the code was directly referencing `projectRoot` instead of `context.projectRoot` in the git repository checks. This fix corrects the variable references to use the proper context object.
+
+## 0.25.0-rc.0
+
+### Minor Changes
+
+- [#1088](https://github.com/eyaltoledano/claude-task-master/pull/1088) [`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8) Thanks [@mm-parthy](https://github.com/mm-parthy)! - Add cross-tag task movement functionality for organizing tasks across different contexts.
+
+  This feature enables moving tasks between different tags (contexts) in your project, making it easier to organize work across different branches, environments, or project phases.
+
+  ## CLI Usage Examples
+
+  Move a single task from one tag to another:
+
+  ```bash
+  # Move task 5 from backlog tag to in-progress tag
+  task-master move --from=5 --from-tag=backlog --to-tag=feature-1
+
+  # Move task with its dependencies
+  task-master move --from=5 --from-tag=backlog --to-tag=feature-2 --with-dependencies
+
+  # Move task without checking dependencies
+  task-master move --from=5 --from-tag=backlog --to-tag=bug-3 --ignore-dependencies
+  ```
+
+  Move multiple tasks at once:
+
+  ```bash
+  # Move multiple tasks between tags
+  task-master move --from=5,6,7 --from-tag=backlog --to-tag=bug-4 --with-dependencies
+  ```
+
+- [#1040](https://github.com/eyaltoledano/claude-task-master/pull/1040) [`fc47714`](https://github.com/eyaltoledano/claude-task-master/commit/fc477143400fd11d953727bf1b4277af5ad308d1) Thanks [@DomVidja](https://github.com/DomVidja)! - "Add Kilo Code profile integration with custom modes and MCP configuration"
+
+- [#1054](https://github.com/eyaltoledano/claude-task-master/pull/1054) [`782728f`](https://github.com/eyaltoledano/claude-task-master/commit/782728ff95aa2e3b766d48273b57f6c6753e8573) Thanks [@martincik](https://github.com/martincik)! - Add compact mode --compact / -c flag to the `tm list` CLI command
+  - outputs tasks in a minimal, git-style one-line format. This reduces verbose output from ~30+ lines of dashboards and tables to just 1 line per task, making it much easier to quickly scan available tasks.
+    - Git-style format: ID STATUS TITLE (PRIORITY) → DEPS
+    - Color-coded status, priority, and dependencies
+    - Smart title truncation and dependency abbreviation
+    - Subtask support with indentation
+    - Full backward compatibility with existing list options
+
+- [#1048](https://github.com/eyaltoledano/claude-task-master/pull/1048) [`e3ed4d7`](https://github.com/eyaltoledano/claude-task-master/commit/e3ed4d7c14b56894d7da675eb2b757423bea8f9d) Thanks [@joedanz](https://github.com/joedanz)! - Add CLI & MCP progress tracking for parse-prd command.
+
+- [#1124](https://github.com/eyaltoledano/claude-task-master/pull/1124) [`95640dc`](https://github.com/eyaltoledano/claude-task-master/commit/95640dcde87ce7879858c0a951399fb49f3b6397) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add support for ollama `gpt-oss:20b` and `gpt-oss:120b`
+
+- [#1123](https://github.com/eyaltoledano/claude-task-master/pull/1123) [`311b243`](https://github.com/eyaltoledano/claude-task-master/commit/311b2433e23c771c8d3a4d3f5ac577302b8321e5) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Remove `clear` Taskmaster claude code commands since they were too close to the claude-code clear command
+
+### Patch Changes
+
+- [#1131](https://github.com/eyaltoledano/claude-task-master/pull/1131) [`3dee60d`](https://github.com/eyaltoledano/claude-task-master/commit/3dee60dc3d566e3cff650accb30f994b8bb3a15e) Thanks [@joedanz](https://github.com/joedanz)! - Update Cursor one-click install link to new URL format
+
+- [#1088](https://github.com/eyaltoledano/claude-task-master/pull/1088) [`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8) Thanks [@mm-parthy](https://github.com/mm-parthy)! - Fix `add-tag --from-branch` command error where `projectRoot` was not properly referenced
+
+  The command was failing with "projectRoot is not defined" error because the code was directly referencing `projectRoot` instead of `context.projectRoot` in the git repository checks. This fix corrects the variable references to use the proper context object.
+
 ## 0.24.0
 
 ### Minor Changes

README.md

@@ -56,7 +56,7 @@ The following documentation is also available in the `docs` directory:
 
 #### Quick Install for Cursor 1.0+ (One-Click)
 
-[![Add task-master-ai MCP server to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=task-master-ai&config=eyJjb21tYW5kIjoibnB4IC15IC0tcGFja2FnZT10YXNrLW1hc3Rlci1haSB0YXNrLW1hc3Rlci1haSIsImVudiI6eyJBTlRIUk9QSUNfQVBJX0tFWSI6IllPVVJfQU5USFJPUElDX0FQSV9LRVlfSEVSRSIsIlBFUlBMRVhJVFlfQVBJX0tFWSI6IllPVVJfUEVSUExFWElUWV9BUElfS0VZX0hFUkUiLCJPUEVOQUlfQVBJX0tFWSI6IllPVVJfT1BFTkFJX0tFWV9IRVJFIiwiR09PR0xFX0FQSV9LRVkiOiJZT1VSX0dPT0dMRV9LRVlfSEVSRSIsIk1JU1RSQUxfQVBJX0tFWSI6IllPVVJfTUlTVFJBTF9LRVlfSEVSRSIsIkdST1FfQVBJX0tFWSI6IllPVVJfR1JPUV9LRVlfSEVSRSIsIk9QRU5ST1VURVJfQVBJX0tFWSI6IllPVVJfT1BFTlJPVVRFUl9LRVlfSEVSRSIsIlhBSV9BUElfS0VZIjoiWU9VUl9YQUlfS0VZX0hFUkUiLCJBWlVSRV9PUEVOQUlfQVBJX0tFWSI6IllPVVJfQVpVUkVfS0VZX0hFUkUiLCJPTExBTUFfQVBJX0tFWSI6IllPVVJfT0xMQU1BX0FQSV9LRVlfSEVSRSJ9fQ%3D%3D)
+[![Add task-master-ai MCP server to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=task-master-ai&config=eyJjb21tYW5kIjoibnB4IC15IC0tcGFja2FnZT10YXNrLW1hc3Rlci1haSB0YXNrLW1hc3Rlci1haSIsImVudiI6eyJBTlRIUk9QSUNfQVBJX0tFWSI6IllPVVJfQU5USFJPUElDX0FQSV9LRVlfSEVSRSIsIlBFUlBMRVhJVFlfQVBJX0tFWSI6IllPVVJfUEVSUExFWElUWV9BUElfS0VZX0hFUkUiLCJPUEVOQUlfQVBJX0tFWSI6IllPVVJfT1BFTkFJX0tFWV9IRVJFIiwiR09PR0xFX0FQSV9LRVkiOiJZT1VSX0dPT0dMRV9LRVlfSEVSRSIsIk1JU1RSQUxfQVBJX0tFWSI6IllPVVJfTUlTVFJBTF9LRVlfSEVSRSIsIkdST1FfQVBJX0tFWSI6IllPVVJfR1JPUV9LRVlfSEVSRSIsIk9QRU5ST1VURVJfQVBJX0tFWSI6IllPVVJfT1BFTlJPVVRFUl9LRVlfSEVSRSIsIlhBSV9BUElfS0VZIjoiWU9VUl9YQUlfS0VZX0hFUkUiLCJBWlVSRV9PUEVOQUlfQVBJX0tFWSI6IllPVVJfQVpVUkVfS0VZX0hFUkUiLCJPTExBTUFfQVBJX0tFWSI6IllPVVJfT0xMQU1BX0FQSV9LRVlfSEVSRSJ9fQ%3D%3D)
 
 > **Note:** After clicking the link, you'll still need to add your API keys to the configuration. The link installs the MCP server with placeholder keys that you'll need to replace with your actual API keys.
 
@@ -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,7 @@ 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 +131,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

@@ -0,0 +1,27 @@
+# @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
+
+- [#1213](https://github.com/eyaltoledano/claude-task-master/pull/1213) [`137ef36`](https://github.com/eyaltoledano/claude-task-master/commit/137ef362789a9cdfdb1925e35e0438c1fa6c69ee) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - testing this stuff out to see how the release candidate works with monorepo
+
+## 1.1.0-rc.0
+
+### Minor Changes
+
+- [#1213](https://github.com/eyaltoledano/claude-task-master/pull/1213) [`cd90b4d`](https://github.com/eyaltoledano/claude-task-master/commit/cd90b4d65fc2f04bdad9fb73aba320b58a124240) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - testing this stuff out to see how the release candidate works with monorepo

apps/cli/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@tm/cli",
+	"description": "Task Master CLI - Command line interface for task management",
+	"type": "module",
+	"private": true,
+	"main": "./dist/index.js",
+	"types": "./src/index.ts",
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"files": ["dist", "README.md"],
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check src",
+		"format": "biome format --write src",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage",
+		"test:unit": "vitest run -t unit",
+		"test:integration": "vitest run -t integration",
+		"test:e2e": "vitest run --dir tests/e2e",
+		"test:ci": "vitest run --coverage --reporter=dot"
+	},
+	"dependencies": {
+		"@tm/core": "*",
+		"boxen": "^8.0.1",
+		"chalk": "5.6.2",
+		"cli-table3": "^0.6.5",
+		"commander": "^12.1.0",
+		"inquirer": "^12.5.0",
+		"ora": "^8.2.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.4",
+		"@types/inquirer": "^9.0.3",
+		"@types/node": "^22.10.5",
+		"tsx": "^4.20.4",
+		"typescript": "^5.7.3",
+		"vitest": "^2.1.8"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"keywords": ["task-master", "cli", "task-management", "productivity"],
+	"author": "",
+	"license": "MIT",
+	"typesVersions": {
+		"*": {
+			"*": ["src/*"]
+		}
+	}
+}

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

@@ -0,0 +1,514 @@
+/**
+ * @fileoverview Auth command using Commander's native class pattern
+ * Extends Commander.Command for better integration with the framework
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora, { type Ora } from 'ora';
+import open from 'open';
+import {
+	AuthManager,
+	AuthenticationError,
+	type AuthCredentials
+} from '@tm/core/auth';
+import * as ui from '../utils/ui.js';
+
+/**
+ * Result type from auth command
+ */
+export interface AuthResult {
+	success: boolean;
+	action: 'login' | 'logout' | 'status' | 'refresh';
+	credentials?: AuthCredentials;
+	message?: string;
+}
+
+/**
+ * AuthCommand extending Commander's Command class
+ * This is a thin presentation layer over @tm/core's AuthManager
+ */
+export class AuthCommand extends Command {
+	private authManager: AuthManager;
+	private lastResult?: AuthResult;
+
+	constructor(name?: string) {
+		super(name || 'auth');
+
+		// Initialize auth manager
+		this.authManager = AuthManager.getInstance();
+
+		// Configure the command with subcommands
+		this.description('Manage authentication with tryhamster.com');
+
+		// Add subcommands
+		this.addLoginCommand();
+		this.addLogoutCommand();
+		this.addStatusCommand();
+		this.addRefreshCommand();
+
+		// Default action shows help
+		this.action(() => {
+			this.help();
+		});
+	}
+
+	/**
+	 * Add login subcommand
+	 */
+	private addLoginCommand(): void {
+		this.command('login')
+			.description('Authenticate with tryhamster.com')
+			.action(async () => {
+				await this.executeLogin();
+			});
+	}
+
+	/**
+	 * Add logout subcommand
+	 */
+	private addLogoutCommand(): void {
+		this.command('logout')
+			.description('Logout and clear credentials')
+			.action(async () => {
+				await this.executeLogout();
+			});
+	}
+
+	/**
+	 * Add status subcommand
+	 */
+	private addStatusCommand(): void {
+		this.command('status')
+			.description('Display authentication status')
+			.action(async () => {
+				await this.executeStatus();
+			});
+	}
+
+	/**
+	 * Add refresh subcommand
+	 */
+	private addRefreshCommand(): void {
+		this.command('refresh')
+			.description('Refresh authentication token')
+			.action(async () => {
+				await this.executeRefresh();
+			});
+	}
+
+	/**
+	 * Execute login command
+	 */
+	private async executeLogin(): Promise<void> {
+		try {
+			const result = await this.performInteractiveAuth();
+			this.setLastResult(result);
+
+			if (!result.success) {
+				process.exit(1);
+			}
+
+			// Exit cleanly after successful authentication
+			// Small delay to ensure all output is flushed
+			setTimeout(() => {
+				process.exit(0);
+			}, 100);
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Execute logout command
+	 */
+	private async executeLogout(): Promise<void> {
+		try {
+			const result = await this.performLogout();
+			this.setLastResult(result);
+
+			if (!result.success) {
+				process.exit(1);
+			}
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Execute status command
+	 */
+	private async executeStatus(): Promise<void> {
+		try {
+			const result = this.displayStatus();
+			this.setLastResult(result);
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Execute refresh command
+	 */
+	private async executeRefresh(): Promise<void> {
+		try {
+			const result = await this.refreshToken();
+			this.setLastResult(result);
+
+			if (!result.success) {
+				process.exit(1);
+			}
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Display authentication status
+	 */
+	private displayStatus(): AuthResult {
+		const credentials = this.authManager.getCredentials();
+
+		console.log(chalk.cyan('\n🔐 Authentication Status\n'));
+
+		if (credentials) {
+			console.log(chalk.green('✓ Authenticated'));
+			console.log(chalk.gray(`  Email: ${credentials.email || 'N/A'}`));
+			console.log(chalk.gray(`  User ID: ${credentials.userId}`));
+			console.log(
+				chalk.gray(`  Token Type: ${credentials.tokenType || 'standard'}`)
+			);
+
+			if (credentials.expiresAt) {
+				const expiresAt = new Date(credentials.expiresAt);
+				const now = new Date();
+				const hoursRemaining = Math.floor(
+					(expiresAt.getTime() - now.getTime()) / (1000 * 60 * 60)
+				);
+
+				if (hoursRemaining > 0) {
+					console.log(
+						chalk.gray(
+							`  Expires: ${expiresAt.toLocaleString()} (${hoursRemaining} hours remaining)`
+						)
+					);
+				} else {
+					console.log(
+						chalk.yellow(`  Token expired at: ${expiresAt.toLocaleString()}`)
+					);
+				}
+			} else {
+				console.log(chalk.gray('  Expires: Never (API key)'));
+			}
+
+			console.log(
+				chalk.gray(`  Saved: ${new Date(credentials.savedAt).toLocaleString()}`)
+			);
+
+			return {
+				success: true,
+				action: 'status',
+				credentials,
+				message: 'Authenticated'
+			};
+		} else {
+			console.log(chalk.yellow('✗ Not authenticated'));
+			console.log(
+				chalk.gray('\n  Run "task-master auth login" to authenticate')
+			);
+
+			return {
+				success: false,
+				action: 'status',
+				message: 'Not authenticated'
+			};
+		}
+	}
+
+	/**
+	 * Perform logout
+	 */
+	private async performLogout(): Promise<AuthResult> {
+		try {
+			await this.authManager.logout();
+			ui.displaySuccess('Successfully logged out');
+
+			return {
+				success: true,
+				action: 'logout',
+				message: 'Successfully logged out'
+			};
+		} catch (error) {
+			const message = `Failed to logout: ${(error as Error).message}`;
+			ui.displayError(message);
+
+			return {
+				success: false,
+				action: 'logout',
+				message
+			};
+		}
+	}
+
+	/**
+	 * Refresh authentication token
+	 */
+	private async refreshToken(): Promise<AuthResult> {
+		const spinner = ora('Refreshing authentication token...').start();
+
+		try {
+			const credentials = await this.authManager.refreshToken();
+			spinner.succeed('Token refreshed successfully');
+
+			console.log(
+				chalk.gray(
+					`  New expiration: ${credentials.expiresAt ? new Date(credentials.expiresAt).toLocaleString() : 'Never'}`
+				)
+			);
+
+			return {
+				success: true,
+				action: 'refresh',
+				credentials,
+				message: 'Token refreshed successfully'
+			};
+		} catch (error) {
+			spinner.fail('Failed to refresh token');
+
+			if ((error as AuthenticationError).code === 'NO_REFRESH_TOKEN') {
+				ui.displayWarning(
+					'No refresh token available. Please re-authenticate.'
+				);
+			} else {
+				ui.displayError(`Refresh failed: ${(error as Error).message}`);
+			}
+
+			return {
+				success: false,
+				action: 'refresh',
+				message: `Failed to refresh: ${(error as Error).message}`
+			};
+		}
+	}
+
+	/**
+	 * Perform interactive authentication
+	 */
+	private async performInteractiveAuth(): Promise<AuthResult> {
+		ui.displayBanner('Task Master Authentication');
+
+		// Check if already authenticated
+		if (this.authManager.isAuthenticated()) {
+			const { continueAuth } = await inquirer.prompt([
+				{
+					type: 'confirm',
+					name: 'continueAuth',
+					message:
+						'You are already authenticated. Do you want to re-authenticate?',
+					default: false
+				}
+			]);
+
+			if (!continueAuth) {
+				const credentials = this.authManager.getCredentials();
+				ui.displaySuccess('Using existing authentication');
+
+				if (credentials) {
+					console.log(chalk.gray(`  Email: ${credentials.email || 'N/A'}`));
+					console.log(chalk.gray(`  User ID: ${credentials.userId}`));
+				}
+
+				return {
+					success: true,
+					action: 'login',
+					credentials: credentials || undefined,
+					message: 'Using existing authentication'
+				};
+			}
+		}
+
+		try {
+			// Direct browser authentication - no menu needed
+			const credentials = await this.authenticateWithBrowser();
+
+			ui.displaySuccess('Authentication successful!');
+			console.log(
+				chalk.gray(`  Logged in as: ${credentials.email || credentials.userId}`)
+			);
+
+			return {
+				success: true,
+				action: 'login',
+				credentials,
+				message: 'Authentication successful'
+			};
+		} catch (error) {
+			this.handleAuthError(error as AuthenticationError);
+
+			return {
+				success: false,
+				action: 'login',
+				message: `Authentication failed: ${(error as Error).message}`
+			};
+		}
+	}
+
+	/**
+	 * Authenticate with browser using OAuth 2.0 with PKCE
+	 */
+	private async authenticateWithBrowser(): Promise<AuthCredentials> {
+		let authSpinner: Ora | null = null;
+
+		try {
+			// Use AuthManager's new unified OAuth flow method with callbacks
+			const credentials = await this.authManager.authenticateWithOAuth({
+				// Callback to handle browser opening
+				openBrowser: async (authUrl) => {
+					await open(authUrl);
+				},
+				timeout: 5 * 60 * 1000, // 5 minutes
+
+				// Callback when auth URL is ready
+				onAuthUrl: (authUrl) => {
+					// Display authentication instructions
+					console.log(chalk.blue.bold('\n🔐 Browser Authentication\n'));
+					console.log(chalk.white('  Opening your browser to authenticate...'));
+					console.log(chalk.gray("  If the browser doesn't open, visit:"));
+					console.log(chalk.cyan.underline(`  ${authUrl}\n`));
+				},
+
+				// Callback when waiting for authentication
+				onWaitingForAuth: () => {
+					authSpinner = ora({
+						text: 'Waiting for authentication...',
+						spinner: 'dots'
+					}).start();
+				},
+
+				// Callback on success
+				onSuccess: () => {
+					if (authSpinner) {
+						authSpinner.succeed('Authentication successful!');
+					}
+				},
+
+				// Callback on error
+				onError: () => {
+					if (authSpinner) {
+						authSpinner.fail('Authentication failed');
+					}
+				}
+			});
+
+			return credentials;
+		} catch (error) {
+			throw error;
+		}
+	}
+
+	/**
+	 * Handle authentication errors
+	 */
+	private handleAuthError(error: AuthenticationError): void {
+		console.error(chalk.red(`\n✗ ${error.message}`));
+
+		switch (error.code) {
+			case 'NETWORK_ERROR':
+				ui.displayWarning(
+					'Please check your internet connection and try again.'
+				);
+				break;
+			case 'INVALID_CREDENTIALS':
+				ui.displayWarning('Please check your credentials and try again.');
+				break;
+			case 'AUTH_EXPIRED':
+				ui.displayWarning(
+					'Your session has expired. Please authenticate again.'
+				);
+				break;
+			default:
+				if (process.env.DEBUG) {
+					console.error(chalk.gray(error.stack || ''));
+				}
+		}
+	}
+
+	/**
+	 * Handle general errors
+	 */
+	private handleError(error: any): void {
+		if (error instanceof AuthenticationError) {
+			this.handleAuthError(error);
+		} else {
+			const msg = error?.getSanitizedDetails?.() ?? {
+				message: error?.message ?? String(error)
+			};
+			console.error(chalk.red(`Error: ${msg.message || 'Unexpected error'}`));
+
+			if (error.stack && process.env.DEBUG) {
+				console.error(chalk.gray(error.stack));
+			}
+		}
+	}
+
+	/**
+	 * Set the last result for programmatic access
+	 */
+	private setLastResult(result: AuthResult): void {
+		this.lastResult = result;
+	}
+
+	/**
+	 * Get the last result (for programmatic usage)
+	 */
+	getLastResult(): AuthResult | undefined {
+		return this.lastResult;
+	}
+
+	/**
+	 * Get current authentication status (for programmatic usage)
+	 */
+	isAuthenticated(): boolean {
+		return this.authManager.isAuthenticated();
+	}
+
+	/**
+	 * Get current credentials (for programmatic usage)
+	 */
+	getCredentials(): AuthCredentials | null {
+		return this.authManager.getCredentials();
+	}
+
+	/**
+	 * Clean up resources
+	 */
+	async cleanup(): Promise<void> {
+		// No resources to clean up for auth command
+		// But keeping method for consistency with other commands
+	}
+
+	/**
+	 * Static method to register this command on an existing program
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const authCommand = new AuthCommand();
+		program.addCommand(authCommand);
+		return authCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
+	 */
+	static register(program: Command, name?: string): AuthCommand {
+		const authCommand = new AuthCommand(name);
+		program.addCommand(authCommand);
+		return authCommand;
+	}
+}

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

@@ -0,0 +1,713 @@
+/**
+ * @fileoverview Context command for managing org/brief selection
+ * Provides a clean interface for workspace context management
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora, { Ora } from 'ora';
+import {
+	AuthManager,
+	AuthenticationError,
+	type UserContext
+} from '@tm/core/auth';
+import * as ui from '../utils/ui.js';
+
+/**
+ * Result type from context command
+ */
+export interface ContextResult {
+	success: boolean;
+	action: 'show' | 'select-org' | 'select-brief' | 'clear' | 'set';
+	context?: UserContext;
+	message?: string;
+}
+
+/**
+ * ContextCommand extending Commander's Command class
+ * Manages user's workspace context (org/brief selection)
+ */
+export class ContextCommand extends Command {
+	private authManager: AuthManager;
+	private lastResult?: ContextResult;
+
+	constructor(name?: string) {
+		super(name || 'context');
+
+		// Initialize auth manager
+		this.authManager = AuthManager.getInstance();
+
+		// Configure the command
+		this.description(
+			'Manage workspace context (organization and brief selection)'
+		);
+
+		// Add subcommands
+		this.addOrgCommand();
+		this.addBriefCommand();
+		this.addClearCommand();
+		this.addSetCommand();
+
+		// 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();
+		});
+	}
+
+	/**
+	 * Add org selection subcommand
+	 */
+	private addOrgCommand(): void {
+		this.command('org')
+			.description('Select an organization')
+			.action(async () => {
+				await this.executeSelectOrg();
+			});
+	}
+
+	/**
+	 * Add brief selection subcommand
+	 */
+	private addBriefCommand(): void {
+		this.command('brief')
+			.description('Select a brief within the current organization')
+			.action(async () => {
+				await this.executeSelectBrief();
+			});
+	}
+
+	/**
+	 * Add clear subcommand
+	 */
+	private addClearCommand(): void {
+		this.command('clear')
+			.description('Clear all context selections')
+			.action(async () => {
+				await this.executeClear();
+			});
+	}
+
+	/**
+	 * Add set subcommand for direct context setting
+	 */
+	private addSetCommand(): void {
+		this.command('set')
+			.description('Set context directly')
+			.option('--org <id>', 'Organization ID')
+			.option('--org-name <name>', 'Organization name')
+			.option('--brief <id>', 'Brief ID')
+			.option('--brief-name <name>', 'Brief name')
+			.action(async (options) => {
+				await this.executeSet(options);
+			});
+	}
+
+	/**
+	 * Execute show current context
+	 */
+	private async executeShow(): Promise<void> {
+		try {
+			const result = this.displayContext();
+			this.setLastResult(result);
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Display current context
+	 */
+	private displayContext(): ContextResult {
+		// Check authentication first
+		if (!this.authManager.isAuthenticated()) {
+			console.log(chalk.yellow('✗ Not authenticated'));
+			console.log(chalk.gray('\n  Run "tm auth login" to authenticate first'));
+
+			return {
+				success: false,
+				action: 'show',
+				message: 'Not authenticated'
+			};
+		}
+
+		const context = this.authManager.getContext();
+
+		console.log(chalk.cyan('\n🌍 Workspace Context\n'));
+
+		if (context && (context.orgId || context.briefId)) {
+			if (context.orgName || context.orgId) {
+				console.log(chalk.green('✓ Organization'));
+				if (context.orgName) {
+					console.log(chalk.white(`  ${context.orgName}`));
+				}
+				if (context.orgId) {
+					console.log(chalk.gray(`  ID: ${context.orgId}`));
+				}
+			}
+
+			if (context.briefName || context.briefId) {
+				console.log(chalk.green('\n✓ Brief'));
+				if (context.briefName) {
+					console.log(chalk.white(`  ${context.briefName}`));
+				}
+				if (context.briefId) {
+					console.log(chalk.gray(`  ID: ${context.briefId}`));
+				}
+			}
+
+			if (context.updatedAt) {
+				console.log(
+					chalk.gray(
+						`\n  Last updated: ${new Date(context.updatedAt).toLocaleString()}`
+					)
+				);
+			}
+
+			return {
+				success: true,
+				action: 'show',
+				context,
+				message: 'Context loaded'
+			};
+		} else {
+			console.log(chalk.yellow('✗ No context selected'));
+			console.log(
+				chalk.gray('\n  Run "tm context org" to select an organization')
+			);
+			console.log(chalk.gray('  Run "tm context brief" to select a brief'));
+
+			return {
+				success: true,
+				action: 'show',
+				message: 'No context selected'
+			};
+		}
+	}
+
+	/**
+	 * Execute org selection
+	 */
+	private async executeSelectOrg(): Promise<void> {
+		try {
+			// Check authentication
+			if (!this.authManager.isAuthenticated()) {
+				ui.displayError('Not authenticated. Run "tm auth login" first.');
+				process.exit(1);
+			}
+
+			const result = await this.selectOrganization();
+			this.setLastResult(result);
+
+			if (!result.success) {
+				process.exit(1);
+			}
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Select an organization interactively
+	 */
+	private async selectOrganization(): Promise<ContextResult> {
+		const spinner = ora('Fetching organizations...').start();
+
+		try {
+			// Fetch organizations from API
+			const organizations = await this.authManager.getOrganizations();
+			spinner.stop();
+
+			if (organizations.length === 0) {
+				ui.displayWarning('No organizations available');
+				return {
+					success: false,
+					action: 'select-org',
+					message: 'No organizations available'
+				};
+			}
+
+			// Prompt for selection
+			const { selectedOrg } = await inquirer.prompt([
+				{
+					type: 'list',
+					name: 'selectedOrg',
+					message: 'Select an organization:',
+					choices: organizations.map((org) => ({
+						name: org.name,
+						value: org
+					}))
+				}
+			]);
+
+			// Update context
+			await this.authManager.updateContext({
+				orgId: selectedOrg.id,
+				orgName: selectedOrg.name,
+				// Clear brief when changing org
+				briefId: undefined,
+				briefName: undefined
+			});
+
+			ui.displaySuccess(`Selected organization: ${selectedOrg.name}`);
+
+			return {
+				success: true,
+				action: 'select-org',
+				context: this.authManager.getContext() || undefined,
+				message: `Selected organization: ${selectedOrg.name}`
+			};
+		} catch (error) {
+			spinner.fail('Failed to fetch organizations');
+			throw error;
+		}
+	}
+
+	/**
+	 * Execute brief selection
+	 */
+	private async executeSelectBrief(): Promise<void> {
+		try {
+			// Check authentication
+			if (!this.authManager.isAuthenticated()) {
+				ui.displayError('Not authenticated. Run "tm auth login" first.');
+				process.exit(1);
+			}
+
+			// Check if org is selected
+			const context = this.authManager.getContext();
+			if (!context?.orgId) {
+				ui.displayError(
+					'No organization selected. Run "tm context org" first.'
+				);
+				process.exit(1);
+			}
+
+			const result = await this.selectBrief(context.orgId);
+			this.setLastResult(result);
+
+			if (!result.success) {
+				process.exit(1);
+			}
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Select a brief within the current organization
+	 */
+	private async selectBrief(orgId: string): Promise<ContextResult> {
+		const spinner = ora('Fetching briefs...').start();
+
+		try {
+			// Fetch briefs from API
+			const briefs = await this.authManager.getBriefs(orgId);
+			spinner.stop();
+
+			if (briefs.length === 0) {
+				ui.displayWarning('No briefs available in this organization');
+				return {
+					success: false,
+					action: 'select-brief',
+					message: 'No briefs available'
+				};
+			}
+
+			// Prompt for selection
+			const { selectedBrief } = await inquirer.prompt([
+				{
+					type: 'list',
+					name: 'selectedBrief',
+					message: 'Select a brief:',
+					choices: [
+						{ name: '(No brief - organization level)', value: null },
+						...briefs.map((brief) => ({
+							name: `Brief ${brief.id} (${new Date(brief.createdAt).toLocaleDateString()})`,
+							value: brief
+						}))
+					]
+				}
+			]);
+
+			if (selectedBrief) {
+				// Update context with brief
+				const briefName = `Brief ${selectedBrief.id.slice(0, 8)}`;
+				await this.authManager.updateContext({
+					briefId: selectedBrief.id,
+					briefName: briefName
+				});
+
+				ui.displaySuccess(`Selected brief: ${briefName}`);
+
+				return {
+					success: true,
+					action: 'select-brief',
+					context: this.authManager.getContext() || undefined,
+					message: `Selected brief: ${selectedBrief.name}`
+				};
+			} else {
+				// Clear brief selection
+				await this.authManager.updateContext({
+					briefId: undefined,
+					briefName: undefined
+				});
+
+				ui.displaySuccess('Cleared brief selection (organization level)');
+
+				return {
+					success: true,
+					action: 'select-brief',
+					context: this.authManager.getContext() || undefined,
+					message: 'Cleared brief selection'
+				};
+			}
+		} catch (error) {
+			spinner.fail('Failed to fetch briefs');
+			throw error;
+		}
+	}
+
+	/**
+	 * Execute clear context
+	 */
+	private async executeClear(): Promise<void> {
+		try {
+			// Check authentication
+			if (!this.authManager.isAuthenticated()) {
+				ui.displayError('Not authenticated. Run "tm auth login" first.');
+				process.exit(1);
+			}
+
+			const result = await this.clearContext();
+			this.setLastResult(result);
+
+			if (!result.success) {
+				process.exit(1);
+			}
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Clear all context selections
+	 */
+	private async clearContext(): Promise<ContextResult> {
+		try {
+			await this.authManager.clearContext();
+			ui.displaySuccess('Context cleared');
+
+			return {
+				success: true,
+				action: 'clear',
+				message: 'Context cleared'
+			};
+		} catch (error) {
+			ui.displayError(`Failed to clear context: ${(error as Error).message}`);
+
+			return {
+				success: false,
+				action: 'clear',
+				message: `Failed to clear context: ${(error as Error).message}`
+			};
+		}
+	}
+
+	/**
+	 * Execute set context with options
+	 */
+	private async executeSet(options: any): Promise<void> {
+		try {
+			// Check authentication
+			if (!this.authManager.isAuthenticated()) {
+				ui.displayError('Not authenticated. Run "tm auth login" first.');
+				process.exit(1);
+			}
+
+			const result = await this.setContext(options);
+			this.setLastResult(result);
+
+			if (!result.success) {
+				process.exit(1);
+			}
+		} catch (error: any) {
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * 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
+	 */
+	private async setContext(options: any): Promise<ContextResult> {
+		try {
+			const context: Partial<UserContext> = {};
+
+			if (options.org) {
+				context.orgId = options.org;
+			}
+			if (options.orgName) {
+				context.orgName = options.orgName;
+			}
+			if (options.brief) {
+				context.briefId = options.brief;
+			}
+			if (options.briefName) {
+				context.briefName = options.briefName;
+			}
+
+			if (Object.keys(context).length === 0) {
+				ui.displayWarning('No context options provided');
+				return {
+					success: false,
+					action: 'set',
+					message: 'No context options provided'
+				};
+			}
+
+			await this.authManager.updateContext(context);
+			ui.displaySuccess('Context updated');
+
+			// Display what was set
+			if (context.orgName || context.orgId) {
+				console.log(
+					chalk.gray(`  Organization: ${context.orgName || context.orgId}`)
+				);
+			}
+			if (context.briefName || context.briefId) {
+				console.log(
+					chalk.gray(`  Brief: ${context.briefName || context.briefId}`)
+				);
+			}
+
+			return {
+				success: true,
+				action: 'set',
+				context: this.authManager.getContext() || undefined,
+				message: 'Context updated'
+			};
+		} catch (error) {
+			ui.displayError(`Failed to set context: ${(error as Error).message}`);
+
+			return {
+				success: false,
+				action: 'set',
+				message: `Failed to set context: ${(error as Error).message}`
+			};
+		}
+	}
+
+	/**
+	 * Handle errors
+	 */
+	private handleError(error: any): void {
+		if (error instanceof AuthenticationError) {
+			console.error(chalk.red(`\n✗ ${error.message}`));
+
+			if (error.code === 'NOT_AUTHENTICATED') {
+				ui.displayWarning('Please authenticate first: tm auth login');
+			}
+		} else {
+			const msg = error?.message ?? String(error);
+			console.error(chalk.red(`Error: ${msg}`));
+
+			if (error.stack && process.env.DEBUG) {
+				console.error(chalk.gray(error.stack));
+			}
+		}
+	}
+
+	/**
+	 * Set the last result for programmatic access
+	 */
+	private setLastResult(result: ContextResult): void {
+		this.lastResult = result;
+	}
+
+	/**
+	 * Get the last result (for programmatic usage)
+	 */
+	getLastResult(): ContextResult | undefined {
+		return this.lastResult;
+	}
+
+	/**
+	 * Get current context (for programmatic usage)
+	 */
+	getContext(): UserContext | null {
+		return this.authManager.getContext();
+	}
+
+	/**
+	 * Clean up resources
+	 */
+	async cleanup(): Promise<void> {
+		// No resources to clean up for context command
+	}
+
+	/**
+	 * Static method to register this command on an existing program
+	 */
+	static registerOn(program: Command): Command {
+		const contextCommand = new ContextCommand();
+		program.addCommand(contextCommand);
+		return contextCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 */
+	static register(program: Command, name?: string): ContextCommand {
+		const contextCommand = new ContextCommand(name);
+		program.addCommand(contextCommand);
+		return contextCommand;
+	}
+}

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

@@ -0,0 +1,488 @@
+/**
+ * @fileoverview ListTasks command using Commander's native class pattern
+ * Extends Commander.Command for better integration with the framework
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import {
+	createTaskMasterCore,
+	type Task,
+	type TaskStatus,
+	type TaskMasterCore,
+	TASK_STATUSES,
+	OUTPUT_FORMATS,
+	STATUS_ICONS,
+	type OutputFormat
+} from '@tm/core';
+import type { StorageType } from '@tm/core/types';
+import * as ui from '../utils/ui.js';
+import {
+	displayHeader,
+	displayDashboards,
+	calculateTaskStatistics,
+	calculateSubtaskStatistics,
+	calculateDependencyStatistics,
+	getPriorityBreakdown,
+	displayRecommendedNextTask,
+	getTaskDescription,
+	displaySuggestedNextSteps,
+	type NextTaskInfo
+} from '../ui/index.js';
+
+/**
+ * Options interface for the list command
+ */
+export interface ListCommandOptions {
+	status?: string;
+	tag?: string;
+	withSubtasks?: boolean;
+	format?: OutputFormat;
+	silent?: boolean;
+	project?: string;
+}
+
+/**
+ * Result type from list command
+ */
+export interface ListTasksResult {
+	tasks: Task[];
+	total: number;
+	filtered: number;
+	tag?: string;
+	storageType: Exclude<StorageType, 'auto'>;
+}
+
+/**
+ * ListTasksCommand extending Commander's Command class
+ * This is a thin presentation layer over @tm/core
+ */
+export class ListTasksCommand extends Command {
+	private tmCore?: TaskMasterCore;
+	private lastResult?: ListTasksResult;
+
+	constructor(name?: string) {
+		super(name || 'list');
+
+		// Configure the command
+		this.description('List tasks with optional filtering')
+			.alias('ls')
+			.option('-s, --status <status>', 'Filter by status (comma-separated)')
+			.option('-t, --tag <tag>', 'Filter by tag')
+			.option('--with-subtasks', 'Include subtasks in the output')
+			.option(
+				'-f, --format <format>',
+				'Output format (text, json, compact)',
+				'text'
+			)
+			.option('--silent', 'Suppress output (useful for programmatic usage)')
+			.option('-p, --project <path>', 'Project root directory', process.cwd())
+			.action(async (options: ListCommandOptions) => {
+				await this.executeCommand(options);
+			});
+	}
+
+	/**
+	 * Execute the list command
+	 */
+	private async executeCommand(options: ListCommandOptions): Promise<void> {
+		try {
+			// Validate options
+			if (!this.validateOptions(options)) {
+				process.exit(1);
+			}
+
+			// Initialize tm-core
+			await this.initializeCore(options.project || process.cwd());
+
+			// Get tasks from core
+			const result = await this.getTasks(options);
+
+			// Store result for programmatic access
+			this.setLastResult(result);
+
+			// Display results
+			if (!options.silent) {
+				this.displayResults(result, options);
+			}
+		} catch (error: any) {
+			const msg = error?.getSanitizedDetails?.() ?? {
+				message: error?.message ?? String(error)
+			};
+			console.error(chalk.red(`Error: ${msg.message || 'Unexpected error'}`));
+			if (error.stack && process.env.DEBUG) {
+				console.error(chalk.gray(error.stack));
+			}
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Validate command options
+	 */
+	private validateOptions(options: ListCommandOptions): boolean {
+		// Validate format
+		if (
+			options.format &&
+			!OUTPUT_FORMATS.includes(options.format as OutputFormat)
+		) {
+			console.error(chalk.red(`Invalid format: ${options.format}`));
+			console.error(chalk.gray(`Valid formats: ${OUTPUT_FORMATS.join(', ')}`));
+			return false;
+		}
+
+		// Validate status
+		if (options.status) {
+			const statuses = options.status.split(',').map((s: string) => s.trim());
+
+			for (const status of statuses) {
+				if (status !== 'all' && !TASK_STATUSES.includes(status as TaskStatus)) {
+					console.error(chalk.red(`Invalid status: ${status}`));
+					console.error(
+						chalk.gray(`Valid statuses: ${TASK_STATUSES.join(', ')}`)
+					);
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Initialize TaskMasterCore
+	 */
+	private async initializeCore(projectRoot: string): Promise<void> {
+		if (!this.tmCore) {
+			this.tmCore = await createTaskMasterCore({ projectPath: projectRoot });
+		}
+	}
+
+	/**
+	 * Get tasks from tm-core
+	 */
+	private async getTasks(
+		options: ListCommandOptions
+	): Promise<ListTasksResult> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+
+		// Build filter
+		const filter =
+			options.status && options.status !== 'all'
+				? {
+						status: options.status
+							.split(',')
+							.map((s: string) => s.trim() as TaskStatus)
+					}
+				: undefined;
+
+		// Call tm-core
+		const result = await this.tmCore.getTaskList({
+			tag: options.tag,
+			filter,
+			includeSubtasks: options.withSubtasks
+		});
+
+		return result as ListTasksResult;
+	}
+
+	/**
+	 * Display results based on format
+	 */
+	private displayResults(
+		result: ListTasksResult,
+		options: ListCommandOptions
+	): void {
+		const format = (options.format || 'text') as OutputFormat | 'text';
+
+		switch (format) {
+			case 'json':
+				this.displayJson(result);
+				break;
+
+			case 'compact':
+				this.displayCompact(result.tasks, options.withSubtasks);
+				break;
+
+			case 'text':
+			default:
+				this.displayText(result, options.withSubtasks);
+				break;
+		}
+	}
+
+	/**
+	 * Display in JSON format
+	 */
+	private displayJson(data: ListTasksResult): void {
+		console.log(
+			JSON.stringify(
+				{
+					tasks: data.tasks,
+					metadata: {
+						total: data.total,
+						filtered: data.filtered,
+						tag: data.tag,
+						storageType: data.storageType
+					}
+				},
+				null,
+				2
+			)
+		);
+	}
+
+	/**
+	 * Display in compact format
+	 */
+	private displayCompact(tasks: Task[], withSubtasks?: boolean): void {
+		tasks.forEach((task) => {
+			const icon = STATUS_ICONS[task.status];
+			console.log(`${chalk.cyan(task.id)} ${icon} ${task.title}`);
+
+			if (withSubtasks && task.subtasks?.length) {
+				task.subtasks.forEach((subtask) => {
+					const subIcon = STATUS_ICONS[subtask.status];
+					console.log(
+						`  ${chalk.gray(`${task.id}.${subtask.id}`)} ${subIcon} ${chalk.gray(subtask.title)}`
+					);
+				});
+			}
+		});
+	}
+
+	/**
+	 * Display in text format with tables
+	 */
+	private displayText(data: ListTasksResult, withSubtasks?: boolean): void {
+		const { tasks, tag } = data;
+
+		// Get file path for display
+		const filePath = this.tmCore ? `.taskmaster/tasks/tasks.json` : undefined;
+
+		// Display header without banner (banner already shown by main CLI)
+		displayHeader({
+			tag: tag || 'master',
+			filePath: filePath
+		});
+
+		// No tasks message
+		if (tasks.length === 0) {
+			ui.displayWarning('No tasks found matching the criteria.');
+			return;
+		}
+
+		// Calculate statistics
+		const taskStats = calculateTaskStatistics(tasks);
+		const subtaskStats = calculateSubtaskStatistics(tasks);
+		const depStats = calculateDependencyStatistics(tasks);
+		const priorityBreakdown = getPriorityBreakdown(tasks);
+
+		// Find next task following the same logic as findNextTask
+		const nextTask = this.findNextTask(tasks);
+
+		// Display dashboard boxes
+		displayDashboards(
+			taskStats,
+			subtaskStats,
+			priorityBreakdown,
+			depStats,
+			nextTask
+		);
+
+		// Task table - no title, just show the table directly
+		console.log(
+			ui.createTaskTable(tasks, {
+				showSubtasks: withSubtasks,
+				showDependencies: true,
+				showComplexity: true // Enable complexity column
+			})
+		);
+
+		// Display recommended next task section immediately after table
+		if (nextTask) {
+			// Find the full task object to get description
+			const fullTask = tasks.find((t) => String(t.id) === String(nextTask.id));
+			const description = fullTask ? getTaskDescription(fullTask) : undefined;
+
+			displayRecommendedNextTask({
+				...nextTask,
+				status: 'pending', // Next task is typically pending
+				description
+			});
+		} else {
+			displayRecommendedNextTask(undefined);
+		}
+
+		// Display suggested next steps at the end
+		displaySuggestedNextSteps();
+	}
+
+	/**
+	 * Set the last result for programmatic access
+	 */
+	private setLastResult(result: ListTasksResult): void {
+		this.lastResult = result;
+	}
+
+	/**
+	 * Find the next task to work on
+	 * Implements the same logic as scripts/modules/task-manager/find-next-task.js
+	 */
+	private findNextTask(tasks: Task[]): NextTaskInfo | undefined {
+		const priorityValues: Record<string, number> = {
+			critical: 4,
+			high: 3,
+			medium: 2,
+			low: 1
+		};
+
+		// Build set of completed task IDs (including subtasks)
+		const completedIds = new Set<string>();
+		tasks.forEach((t) => {
+			if (t.status === 'done' || t.status === 'completed') {
+				completedIds.add(String(t.id));
+			}
+			if (t.subtasks) {
+				t.subtasks.forEach((st) => {
+					if (st.status === 'done' || st.status === 'completed') {
+						completedIds.add(`${t.id}.${st.id}`);
+					}
+				});
+			}
+		});
+
+		// First, look for eligible subtasks in in-progress parent tasks
+		const candidateSubtasks: NextTaskInfo[] = [];
+
+		tasks
+			.filter(
+				(t) => t.status === 'in-progress' && t.subtasks && t.subtasks.length > 0
+			)
+			.forEach((parent) => {
+				parent.subtasks!.forEach((st) => {
+					const stStatus = (st.status || 'pending').toLowerCase();
+					if (stStatus !== 'pending' && stStatus !== 'in-progress') return;
+
+					// Check if dependencies are satisfied
+					const fullDeps =
+						st.dependencies?.map((d) => {
+							// Handle both numeric and string IDs
+							if (typeof d === 'string' && d.includes('.')) {
+								return d;
+							}
+							return `${parent.id}.${d}`;
+						}) ?? [];
+
+					const depsSatisfied =
+						fullDeps.length === 0 ||
+						fullDeps.every((depId) => completedIds.has(String(depId)));
+
+					if (depsSatisfied) {
+						candidateSubtasks.push({
+							id: `${parent.id}.${st.id}`,
+							title: st.title || `Subtask ${st.id}`,
+							priority: st.priority || parent.priority || 'medium',
+							dependencies: fullDeps.map((d) => String(d))
+						});
+					}
+				});
+			});
+
+		if (candidateSubtasks.length > 0) {
+			// Sort by priority, then by dependencies count, then by ID
+			candidateSubtasks.sort((a, b) => {
+				const pa = priorityValues[a.priority || 'medium'] ?? 2;
+				const pb = priorityValues[b.priority || 'medium'] ?? 2;
+				if (pb !== pa) return pb - pa;
+
+				const depCountA = a.dependencies?.length || 0;
+				const depCountB = b.dependencies?.length || 0;
+				if (depCountA !== depCountB) return depCountA - depCountB;
+
+				return String(a.id).localeCompare(String(b.id));
+			});
+			return candidateSubtasks[0];
+		}
+
+		// Fall back to finding eligible top-level tasks
+		const eligibleTasks = tasks.filter((task) => {
+			// Skip non-eligible statuses
+			const status = (task.status || 'pending').toLowerCase();
+			if (status !== 'pending' && status !== 'in-progress') return false;
+
+			// Check dependencies
+			const deps = task.dependencies || [];
+			const depsSatisfied =
+				deps.length === 0 ||
+				deps.every((depId) => completedIds.has(String(depId)));
+
+			return depsSatisfied;
+		});
+
+		if (eligibleTasks.length === 0) return undefined;
+
+		// Sort eligible tasks
+		eligibleTasks.sort((a, b) => {
+			// Priority (higher first)
+			const pa = priorityValues[a.priority || 'medium'] ?? 2;
+			const pb = priorityValues[b.priority || 'medium'] ?? 2;
+			if (pb !== pa) return pb - pa;
+
+			// Dependencies count (fewer first)
+			const depCountA = a.dependencies?.length || 0;
+			const depCountB = b.dependencies?.length || 0;
+			if (depCountA !== depCountB) return depCountA - depCountB;
+
+			// ID (lower first)
+			return Number(a.id) - Number(b.id);
+		});
+
+		const nextTask = eligibleTasks[0];
+		return {
+			id: nextTask.id,
+			title: nextTask.title,
+			priority: nextTask.priority,
+			dependencies: nextTask.dependencies?.map((d) => String(d))
+		};
+	}
+
+	/**
+	 * Get the last result (for programmatic usage)
+	 */
+	getLastResult(): ListTasksResult | 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
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const listCommand = new ListTasksCommand();
+		program.addCommand(listCommand);
+		return listCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
+	 */
+	static register(program: Command, name?: string): ListTasksCommand {
+		const listCommand = new ListTasksCommand(name);
+		program.addCommand(listCommand);
+		return listCommand;
+	}
+}

apps/cli/src/commands/set-status.command.ts

@@ -0,0 +1,318 @@
+/**
+ * @fileoverview SetStatusCommand using Commander's native class pattern
+ * Extends Commander.Command for better integration with the framework
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import {
+	createTaskMasterCore,
+	type TaskMasterCore,
+	type TaskStatus
+} from '@tm/core';
+import type { StorageType } from '@tm/core/types';
+
+/**
+ * Valid task status values for validation
+ */
+const VALID_TASK_STATUSES: TaskStatus[] = [
+	'pending',
+	'in-progress',
+	'done',
+	'deferred',
+	'cancelled',
+	'blocked',
+	'review'
+];
+
+/**
+ * Options interface for the set-status command
+ */
+export interface SetStatusCommandOptions {
+	id?: string;
+	status?: TaskStatus;
+	format?: 'text' | 'json';
+	silent?: boolean;
+	project?: string;
+}
+
+/**
+ * Result type from set-status command
+ */
+export interface SetStatusResult {
+	success: boolean;
+	updatedTasks: Array<{
+		taskId: string;
+		oldStatus: TaskStatus;
+		newStatus: TaskStatus;
+	}>;
+	storageType: Exclude<StorageType, 'auto'>;
+}
+
+/**
+ * SetStatusCommand extending Commander's Command class
+ * This is a thin presentation layer over @tm/core
+ */
+export class SetStatusCommand extends Command {
+	private tmCore?: TaskMasterCore;
+	private lastResult?: SetStatusResult;
+
+	constructor(name?: string) {
+		super(name || 'set-status');
+
+		// Configure the command
+		this.description('Update the status of one or more tasks')
+			.requiredOption(
+				'-i, --id <id>',
+				'Task ID(s) to update (comma-separated for multiple, supports subtasks like 5.2)'
+			)
+			.requiredOption(
+				'-s, --status <status>',
+				`New status (${VALID_TASK_STATUSES.join(', ')})`
+			)
+			.option('-f, --format <format>', 'Output format (text, json)', 'text')
+			.option('--silent', 'Suppress output (useful for programmatic usage)')
+			.option('-p, --project <path>', 'Project root directory', process.cwd())
+			.action(async (options: SetStatusCommandOptions) => {
+				await this.executeCommand(options);
+			});
+	}
+
+	/**
+	 * Execute the set-status command
+	 */
+	private async executeCommand(
+		options: SetStatusCommandOptions
+	): Promise<void> {
+		try {
+			// Validate required options
+			if (!options.id) {
+				console.error(chalk.red('Error: Task ID is required. Use -i or --id'));
+				process.exit(1);
+			}
+
+			if (!options.status) {
+				console.error(
+					chalk.red('Error: Status is required. Use -s or --status')
+				);
+				process.exit(1);
+			}
+
+			// Validate status
+			if (!VALID_TASK_STATUSES.includes(options.status)) {
+				console.error(
+					chalk.red(
+						`Error: Invalid status "${options.status}". Valid options: ${VALID_TASK_STATUSES.join(', ')}`
+					)
+				);
+				process.exit(1);
+			}
+
+			// Initialize TaskMaster core
+			this.tmCore = await createTaskMasterCore({
+				projectPath: options.project || process.cwd()
+			});
+
+			// Parse task IDs (handle comma-separated values)
+			const taskIds = options.id.split(',').map((id) => id.trim());
+
+			// Update each task
+			const updatedTasks: Array<{
+				taskId: string;
+				oldStatus: TaskStatus;
+				newStatus: TaskStatus;
+			}> = [];
+
+			for (const taskId of taskIds) {
+				try {
+					const result = await this.tmCore.updateTaskStatus(
+						taskId,
+						options.status
+					);
+					updatedTasks.push({
+						taskId: result.taskId,
+						oldStatus: result.oldStatus,
+						newStatus: result.newStatus
+					});
+				} catch (error) {
+					const errorMessage =
+						error instanceof Error ? error.message : String(error);
+
+					if (!options.silent) {
+						console.error(
+							chalk.red(`Failed to update task ${taskId}: ${errorMessage}`)
+						);
+					}
+					if (options.format === 'json') {
+						console.log(
+							JSON.stringify({
+								success: false,
+								error: errorMessage,
+								taskId,
+								timestamp: new Date().toISOString()
+							})
+						);
+					}
+					process.exit(1);
+				}
+			}
+
+			// Store result for potential reuse
+			this.lastResult = {
+				success: true,
+				updatedTasks,
+				storageType: this.tmCore.getStorageType() as Exclude<
+					StorageType,
+					'auto'
+				>
+			};
+
+			// Display results
+			this.displayResults(this.lastResult, options);
+		} catch (error) {
+			const errorMessage =
+				error instanceof Error ? error.message : 'Unknown error occurred';
+
+			if (!options.silent) {
+				console.error(chalk.red(`Error: ${errorMessage}`));
+			}
+
+			if (options.format === 'json') {
+				console.log(JSON.stringify({ success: false, error: errorMessage }));
+			}
+
+			process.exit(1);
+		} finally {
+			// Clean up resources
+			if (this.tmCore) {
+				await this.tmCore.close();
+			}
+		}
+	}
+
+	/**
+	 * Display results based on format
+	 */
+	private displayResults(
+		result: SetStatusResult,
+		options: SetStatusCommandOptions
+	): void {
+		const format = options.format || 'text';
+
+		switch (format) {
+			case 'json':
+				console.log(JSON.stringify(result, null, 2));
+				break;
+
+			case 'text':
+			default:
+				if (!options.silent) {
+					this.displayTextResults(result);
+				}
+				break;
+		}
+	}
+
+	/**
+	 * Display results in text format
+	 */
+	private displayTextResults(result: SetStatusResult): void {
+		if (result.updatedTasks.length === 1) {
+			// Single task update
+			const update = result.updatedTasks[0];
+			console.log(
+				boxen(
+					chalk.white.bold(`✅ Successfully updated task ${update.taskId}`) +
+						'\n\n' +
+						`${chalk.blue('From:')} ${this.getStatusDisplay(update.oldStatus)}\n` +
+						`${chalk.blue('To:')}   ${this.getStatusDisplay(update.newStatus)}`,
+					{
+						padding: 1,
+						borderColor: 'green',
+						borderStyle: 'round',
+						margin: { top: 1 }
+					}
+				)
+			);
+		} else {
+			// Multiple task updates
+			console.log(
+				boxen(
+					chalk.white.bold(
+						`✅ Successfully updated ${result.updatedTasks.length} tasks`
+					) +
+						'\n\n' +
+						result.updatedTasks
+							.map(
+								(update) =>
+									`${chalk.cyan(update.taskId)}: ${this.getStatusDisplay(update.oldStatus)} → ${this.getStatusDisplay(update.newStatus)}`
+							)
+							.join('\n'),
+					{
+						padding: 1,
+						borderColor: 'green',
+						borderStyle: 'round',
+						margin: { top: 1 }
+					}
+				)
+			);
+		}
+
+		// Show storage info
+		console.log(chalk.gray(`\nUsing ${result.storageType} storage`));
+	}
+
+	/**
+	 * Get colored status display
+	 */
+	private getStatusDisplay(status: TaskStatus): string {
+		const statusColors: Record<TaskStatus, (text: string) => string> = {
+			pending: chalk.yellow,
+			'in-progress': chalk.blue,
+			done: chalk.green,
+			deferred: chalk.gray,
+			cancelled: chalk.red,
+			blocked: chalk.red,
+			review: chalk.magenta,
+			completed: chalk.green
+		};
+
+		const colorFn = statusColors[status] || chalk.white;
+		return colorFn(status);
+	}
+
+	/**
+	 * Get the last command result (useful for testing or chaining)
+	 */
+	getLastResult(): SetStatusResult | undefined {
+		return this.lastResult;
+	}
+
+	/**
+	 * Static method to register this command on an existing program
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const setStatusCommand = new SetStatusCommand();
+		program.addCommand(setStatusCommand);
+		return setStatusCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
+	 */
+	static register(program: Command, name?: string): SetStatusCommand {
+		const setStatusCommand = new SetStatusCommand(name);
+		program.addCommand(setStatusCommand);
+		return setStatusCommand;
+	}
+}
+
+/**
+ * Factory function to create and configure the set-status command
+ */
+export function createSetStatusCommand(): SetStatusCommand {
+	return new SetStatusCommand();
+}

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

@@ -0,0 +1,343 @@
+/**
+ * @fileoverview ShowCommand using Commander's native class pattern
+ * Extends Commander.Command for better integration with the framework
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+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 { displayTaskDetails } from '../ui/components/task-detail.component.js';
+
+/**
+ * Options interface for the show command
+ */
+export interface ShowCommandOptions {
+	id?: string;
+	status?: string;
+	format?: 'text' | 'json';
+	silent?: boolean;
+	project?: string;
+}
+
+/**
+ * Result type from show command
+ */
+export interface ShowTaskResult {
+	task: Task | null;
+	found: boolean;
+	storageType: Exclude<StorageType, 'auto'>;
+}
+
+/**
+ * Result type for multiple tasks
+ */
+export interface ShowMultipleTasksResult {
+	tasks: Task[];
+	notFound: string[];
+	storageType: Exclude<StorageType, 'auto'>;
+}
+
+/**
+ * ShowCommand extending Commander's Command class
+ * This is a thin presentation layer over @tm/core
+ */
+export class ShowCommand extends Command {
+	private tmCore?: TaskMasterCore;
+	private lastResult?: ShowTaskResult | ShowMultipleTasksResult;
+
+	constructor(name?: string) {
+		super(name || 'show');
+
+		// Configure the command
+		this.description('Display detailed information about one or more tasks')
+			.argument('[id]', 'Task ID(s) to show (comma-separated for multiple)')
+			.option(
+				'-i, --id <id>',
+				'Task ID(s) to show (comma-separated for multiple)'
+			)
+			.option('-s, --status <status>', 'Filter subtasks by status')
+			.option('-f, --format <format>', 'Output format (text, json)', 'text')
+			.option('--silent', 'Suppress output (useful for programmatic usage)')
+			.option('-p, --project <path>', 'Project root directory', process.cwd())
+			.action(
+				async (taskId: string | undefined, options: ShowCommandOptions) => {
+					await this.executeCommand(taskId, options);
+				}
+			);
+	}
+
+	/**
+	 * Execute the show command
+	 */
+	private async executeCommand(
+		taskId: string | undefined,
+		options: ShowCommandOptions
+	): Promise<void> {
+		try {
+			// Validate options
+			if (!this.validateOptions(options)) {
+				process.exit(1);
+			}
+
+			// Initialize tm-core
+			await this.initializeCore(options.project || process.cwd());
+
+			// Get the task ID from argument or option
+			const idArg = taskId || options.id;
+			if (!idArg) {
+				console.error(chalk.red('Error: Please provide a task ID'));
+				process.exit(1);
+			}
+
+			// Check if multiple IDs are provided (comma-separated)
+			const taskIds = idArg
+				.split(',')
+				.map((id) => id.trim())
+				.filter((id) => id.length > 0);
+
+			// Get tasks from core
+			const result =
+				taskIds.length > 1
+					? await this.getMultipleTasks(taskIds, options)
+					: await this.getSingleTask(taskIds[0], options);
+
+			// Store result for programmatic access
+			this.setLastResult(result);
+
+			// Display results
+			if (!options.silent) {
+				this.displayResults(result, options);
+			}
+		} catch (error: any) {
+			const msg = error?.getSanitizedDetails?.() ?? {
+				message: error?.message ?? String(error)
+			};
+			console.error(chalk.red(`Error: ${msg.message || 'Unexpected error'}`));
+			if (error.stack && process.env.DEBUG) {
+				console.error(chalk.gray(error.stack));
+			}
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Validate command options
+	 */
+	private validateOptions(options: ShowCommandOptions): 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 a single task from tm-core
+	 */
+	private async getSingleTask(
+		taskId: string,
+		_options: ShowCommandOptions
+	): Promise<ShowTaskResult> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+
+		// Get the task
+		const task = await this.tmCore.getTask(taskId);
+
+		// Get storage type
+		const storageType = this.tmCore.getStorageType();
+
+		return {
+			task,
+			found: task !== null,
+			storageType: storageType as Exclude<StorageType, 'auto'>
+		};
+	}
+
+	/**
+	 * Get multiple tasks from tm-core
+	 */
+	private async getMultipleTasks(
+		taskIds: string[],
+		_options: ShowCommandOptions
+	): Promise<ShowMultipleTasksResult> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+
+		const tasks: Task[] = [];
+		const notFound: string[] = [];
+
+		// Get each task individually
+		for (const taskId of taskIds) {
+			const task = await this.tmCore.getTask(taskId);
+			if (task) {
+				tasks.push(task);
+			} else {
+				notFound.push(taskId);
+			}
+		}
+
+		// Get storage type
+		const storageType = this.tmCore.getStorageType();
+
+		return {
+			tasks,
+			notFound,
+			storageType: storageType as Exclude<StorageType, 'auto'>
+		};
+	}
+
+	/**
+	 * Display results based on format
+	 */
+	private displayResults(
+		result: ShowTaskResult | ShowMultipleTasksResult,
+		options: ShowCommandOptions
+	): void {
+		const format = options.format || 'text';
+
+		switch (format) {
+			case 'json':
+				this.displayJson(result);
+				break;
+
+			case 'text':
+			default:
+				if ('task' in result) {
+					// Single task result
+					this.displaySingleTask(result, options);
+				} else {
+					// Multiple tasks result
+					this.displayMultipleTasks(result, options);
+				}
+				break;
+		}
+	}
+
+	/**
+	 * Display in JSON format
+	 */
+	private displayJson(result: ShowTaskResult | ShowMultipleTasksResult): void {
+		console.log(JSON.stringify(result, null, 2));
+	}
+
+	/**
+	 * Display a single task in text format
+	 */
+	private displaySingleTask(
+		result: ShowTaskResult,
+		options: ShowCommandOptions
+	): 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;
+		}
+
+		// Use the global task details display function
+		displayTaskDetails(result.task, {
+			statusFilter: options.status,
+			showSuggestedActions: true
+		});
+	}
+
+	/**
+	 * Display multiple tasks in text format
+	 */
+	private displayMultipleTasks(
+		result: ShowMultipleTasksResult,
+		_options: ShowCommandOptions
+	): void {
+		// Header
+		ui.displayBanner(`Tasks (${result.tasks.length} found)`);
+
+		if (result.notFound.length > 0) {
+			console.log(chalk.yellow(`\n⚠ Not found: ${result.notFound.join(', ')}`));
+		}
+
+		if (result.tasks.length === 0) {
+			ui.displayWarning('No tasks found matching the criteria.');
+			return;
+		}
+
+		// Task table
+		console.log(chalk.blue.bold(`\n📋 Tasks:\n`));
+		console.log(
+			ui.createTaskTable(result.tasks, {
+				showSubtasks: true,
+				showDependencies: true
+			})
+		);
+
+		console.log(`\n${chalk.gray('Storage: ' + result.storageType)}`);
+	}
+
+	/**
+	 * Set the last result for programmatic access
+	 */
+	private setLastResult(
+		result: ShowTaskResult | ShowMultipleTasksResult
+	): void {
+		this.lastResult = result;
+	}
+
+	/**
+	 * Get the last result (for programmatic usage)
+	 */
+	getLastResult(): ShowTaskResult | ShowMultipleTasksResult | 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
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const showCommand = new ShowCommand();
+		program.addCommand(showCommand);
+		return showCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
+	 */
+	static register(program: Command, name?: string): ShowCommand {
+		const showCommand = new ShowCommand(name);
+		program.addCommand(showCommand);
+		return showCommand;
+	}
+}

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

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Main entry point for @tm/cli package
+ * Exports all public APIs for the CLI presentation layer
+ */
+
+// Commands
+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)
+export * as ui from './utils/ui.js';
+
+// Auto-update utilities
+export {
+	checkForUpdate,
+	performAutoUpdate,
+	displayUpgradeNotification,
+	compareVersions
+} from './utils/auto-update.js';
+
+// Re-export commonly used types from tm-core
+export type {
+	Task,
+	TaskStatus,
+	TaskPriority,
+	TaskMasterCore
+} from '@tm/core';

apps/cli/src/ui/components/dashboard.component.ts

@@ -0,0 +1,567 @@
+/**
+ * @fileoverview Dashboard components for Task Master CLI
+ * Displays project statistics and dependency information
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import type { Task, TaskPriority } from '@tm/core/types';
+
+/**
+ * Statistics for task collection
+ */
+export interface TaskStatistics {
+	total: number;
+	done: number;
+	inProgress: number;
+	pending: number;
+	blocked: number;
+	deferred: number;
+	cancelled: number;
+	review?: number;
+	completionPercentage: number;
+}
+
+/**
+ * Statistics for dependencies
+ */
+export interface DependencyStatistics {
+	tasksWithNoDeps: number;
+	tasksReadyToWork: number;
+	tasksBlockedByDeps: number;
+	mostDependedOnTaskId?: number;
+	mostDependedOnCount?: number;
+	avgDependenciesPerTask: number;
+}
+
+/**
+ * Next task information
+ */
+export interface NextTaskInfo {
+	id: string | number;
+	title: string;
+	priority?: TaskPriority;
+	dependencies?: (string | number)[];
+	complexity?: number | string;
+}
+
+/**
+ * Status breakdown for progress bars
+ */
+export interface StatusBreakdown {
+	'in-progress'?: number;
+	pending?: number;
+	blocked?: number;
+	deferred?: number;
+	cancelled?: number;
+	review?: number;
+}
+
+/**
+ * Create a progress bar with color-coded status segments
+ */
+function createProgressBar(
+	completionPercentage: number,
+	width: number = 30,
+	statusBreakdown?: StatusBreakdown
+): string {
+	// If no breakdown provided, use simple green bar
+	if (!statusBreakdown) {
+		const filled = Math.round((completionPercentage / 100) * width);
+		const empty = width - filled;
+		return chalk.green('█').repeat(filled) + chalk.gray('░').repeat(empty);
+	}
+
+	// Build the bar with different colored sections
+	// Order matches the status display: Done, Cancelled, Deferred, In Progress, Review, Pending, Blocked
+	let bar = '';
+	let charsUsed = 0;
+
+	// 1. Green filled blocks for completed tasks (done)
+	const completedChars = Math.round((completionPercentage / 100) * width);
+	if (completedChars > 0) {
+		bar += chalk.green('█').repeat(completedChars);
+		charsUsed += completedChars;
+	}
+
+	// 2. Gray filled blocks for cancelled (won't be done)
+	if (statusBreakdown.cancelled && charsUsed < width) {
+		const cancelledChars = Math.round(
+			(statusBreakdown.cancelled / 100) * width
+		);
+		const actualChars = Math.min(cancelledChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.gray('█').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 3. Gray filled blocks for deferred (won't be done now)
+	if (statusBreakdown.deferred && charsUsed < width) {
+		const deferredChars = Math.round((statusBreakdown.deferred / 100) * width);
+		const actualChars = Math.min(deferredChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.gray('█').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 4. Blue filled blocks for in-progress (actively working)
+	if (statusBreakdown['in-progress'] && charsUsed < width) {
+		const inProgressChars = Math.round(
+			(statusBreakdown['in-progress'] / 100) * width
+		);
+		const actualChars = Math.min(inProgressChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.blue('█').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 5. Magenta empty blocks for review (almost done)
+	if (statusBreakdown.review && charsUsed < width) {
+		const reviewChars = Math.round((statusBreakdown.review / 100) * width);
+		const actualChars = Math.min(reviewChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.magenta('░').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 6. Yellow empty blocks for pending (ready to start)
+	if (statusBreakdown.pending && charsUsed < width) {
+		const pendingChars = Math.round((statusBreakdown.pending / 100) * width);
+		const actualChars = Math.min(pendingChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.yellow('░').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 7. Red empty blocks for blocked (can't start yet)
+	if (statusBreakdown.blocked && charsUsed < width) {
+		const blockedChars = Math.round((statusBreakdown.blocked / 100) * width);
+		const actualChars = Math.min(blockedChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.red('░').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// Fill any remaining space with gray empty yellow blocks
+	if (charsUsed < width) {
+		bar += chalk.yellow('░').repeat(width - charsUsed);
+	}
+
+	return bar;
+}
+
+/**
+ * Calculate task statistics from a list of tasks
+ */
+export function calculateTaskStatistics(tasks: Task[]): TaskStatistics {
+	const stats: TaskStatistics = {
+		total: tasks.length,
+		done: 0,
+		inProgress: 0,
+		pending: 0,
+		blocked: 0,
+		deferred: 0,
+		cancelled: 0,
+		review: 0,
+		completionPercentage: 0
+	};
+
+	tasks.forEach((task) => {
+		switch (task.status) {
+			case 'done':
+				stats.done++;
+				break;
+			case 'in-progress':
+				stats.inProgress++;
+				break;
+			case 'pending':
+				stats.pending++;
+				break;
+			case 'blocked':
+				stats.blocked++;
+				break;
+			case 'deferred':
+				stats.deferred++;
+				break;
+			case 'cancelled':
+				stats.cancelled++;
+				break;
+			case 'review':
+				stats.review = (stats.review || 0) + 1;
+				break;
+		}
+	});
+
+	stats.completionPercentage =
+		stats.total > 0 ? Math.round((stats.done / stats.total) * 100) : 0;
+
+	return stats;
+}
+
+/**
+ * Calculate subtask statistics from tasks
+ */
+export function calculateSubtaskStatistics(tasks: Task[]): TaskStatistics {
+	const stats: TaskStatistics = {
+		total: 0,
+		done: 0,
+		inProgress: 0,
+		pending: 0,
+		blocked: 0,
+		deferred: 0,
+		cancelled: 0,
+		review: 0,
+		completionPercentage: 0
+	};
+
+	tasks.forEach((task) => {
+		if (task.subtasks && task.subtasks.length > 0) {
+			task.subtasks.forEach((subtask) => {
+				stats.total++;
+				switch (subtask.status) {
+					case 'done':
+						stats.done++;
+						break;
+					case 'in-progress':
+						stats.inProgress++;
+						break;
+					case 'pending':
+						stats.pending++;
+						break;
+					case 'blocked':
+						stats.blocked++;
+						break;
+					case 'deferred':
+						stats.deferred++;
+						break;
+					case 'cancelled':
+						stats.cancelled++;
+						break;
+					case 'review':
+						stats.review = (stats.review || 0) + 1;
+						break;
+				}
+			});
+		}
+	});
+
+	stats.completionPercentage =
+		stats.total > 0 ? Math.round((stats.done / stats.total) * 100) : 0;
+
+	return stats;
+}
+
+/**
+ * Calculate dependency statistics
+ */
+export function calculateDependencyStatistics(
+	tasks: Task[]
+): DependencyStatistics {
+	const completedTaskIds = new Set(
+		tasks.filter((t) => t.status === 'done').map((t) => t.id)
+	);
+
+	const tasksWithNoDeps = tasks.filter(
+		(t) =>
+			t.status !== 'done' && (!t.dependencies || t.dependencies.length === 0)
+	).length;
+
+	const tasksWithAllDepsSatisfied = tasks.filter(
+		(t) =>
+			t.status !== 'done' &&
+			t.dependencies &&
+			t.dependencies.length > 0 &&
+			t.dependencies.every((depId) => completedTaskIds.has(depId))
+	).length;
+
+	const tasksBlockedByDeps = tasks.filter(
+		(t) =>
+			t.status !== 'done' &&
+			t.dependencies &&
+			t.dependencies.length > 0 &&
+			!t.dependencies.every((depId) => completedTaskIds.has(depId))
+	).length;
+
+	// Calculate most depended-on task
+	const dependencyCount: Record<string, number> = {};
+	tasks.forEach((task) => {
+		if (task.dependencies && task.dependencies.length > 0) {
+			task.dependencies.forEach((depId) => {
+				const key = String(depId);
+				dependencyCount[key] = (dependencyCount[key] || 0) + 1;
+			});
+		}
+	});
+
+	let mostDependedOnTaskId: number | undefined;
+	let mostDependedOnCount = 0;
+
+	for (const [taskId, count] of Object.entries(dependencyCount)) {
+		if (count > mostDependedOnCount) {
+			mostDependedOnCount = count;
+			mostDependedOnTaskId = parseInt(taskId);
+		}
+	}
+
+	// Calculate average dependencies
+	const totalDependencies = tasks.reduce(
+		(sum, task) => sum + (task.dependencies ? task.dependencies.length : 0),
+		0
+	);
+	const avgDependenciesPerTask =
+		tasks.length > 0 ? totalDependencies / tasks.length : 0;
+
+	return {
+		tasksWithNoDeps,
+		tasksReadyToWork: tasksWithNoDeps + tasksWithAllDepsSatisfied,
+		tasksBlockedByDeps,
+		mostDependedOnTaskId,
+		mostDependedOnCount,
+		avgDependenciesPerTask
+	};
+}
+
+/**
+ * Get priority counts
+ */
+export function getPriorityBreakdown(
+	tasks: Task[]
+): Record<TaskPriority, number> {
+	const breakdown: Record<TaskPriority, number> = {
+		critical: 0,
+		high: 0,
+		medium: 0,
+		low: 0
+	};
+
+	tasks.forEach((task) => {
+		const priority = task.priority || 'medium';
+		breakdown[priority]++;
+	});
+
+	return breakdown;
+}
+
+/**
+ * Calculate status breakdown as percentages
+ */
+function calculateStatusBreakdown(stats: TaskStatistics): StatusBreakdown {
+	if (stats.total === 0) return {};
+
+	return {
+		'in-progress': (stats.inProgress / stats.total) * 100,
+		pending: (stats.pending / stats.total) * 100,
+		blocked: (stats.blocked / stats.total) * 100,
+		deferred: (stats.deferred / stats.total) * 100,
+		cancelled: (stats.cancelled / stats.total) * 100,
+		review: ((stats.review || 0) / stats.total) * 100
+	};
+}
+
+/**
+ * Format status counts in the correct order with colors
+ * @param stats - The statistics object containing counts
+ * @param isSubtask - Whether this is for subtasks (affects "Done" vs "Completed" label)
+ */
+function formatStatusLine(
+	stats: TaskStatistics,
+	isSubtask: boolean = false
+): string {
+	const parts: string[] = [];
+
+	// Order: Done, Cancelled, Deferred, In Progress, Review, Pending, Blocked
+	if (isSubtask) {
+		parts.push(`Completed: ${chalk.green(`${stats.done}/${stats.total}`)}`);
+	} else {
+		parts.push(`Done: ${chalk.green(stats.done)}`);
+	}
+
+	parts.push(`Cancelled: ${chalk.gray(stats.cancelled)}`);
+	parts.push(`Deferred: ${chalk.gray(stats.deferred)}`);
+
+	// Add line break for second row
+	const firstLine = parts.join('  ');
+	parts.length = 0;
+
+	parts.push(`In Progress: ${chalk.blue(stats.inProgress)}`);
+	parts.push(`Review: ${chalk.magenta(stats.review || 0)}`);
+	parts.push(`Pending: ${chalk.yellow(stats.pending)}`);
+	parts.push(`Blocked: ${chalk.red(stats.blocked)}`);
+
+	const secondLine = parts.join('  ');
+
+	return firstLine + '\n' + secondLine;
+}
+
+/**
+ * Display the project dashboard box
+ */
+export function displayProjectDashboard(
+	taskStats: TaskStatistics,
+	subtaskStats: TaskStatistics,
+	priorityBreakdown: Record<TaskPriority, number>
+): string {
+	// Calculate status breakdowns using the helper function
+	const taskStatusBreakdown = calculateStatusBreakdown(taskStats);
+	const subtaskStatusBreakdown = calculateStatusBreakdown(subtaskStats);
+
+	// Create progress bars with the breakdowns
+	const taskProgressBar = createProgressBar(
+		taskStats.completionPercentage,
+		30,
+		taskStatusBreakdown
+	);
+	const subtaskProgressBar = createProgressBar(
+		subtaskStats.completionPercentage,
+		30,
+		subtaskStatusBreakdown
+	);
+
+	const taskPercentage = `${taskStats.completionPercentage}% ${taskStats.done}/${taskStats.total}`;
+	const subtaskPercentage = `${subtaskStats.completionPercentage}% ${subtaskStats.done}/${subtaskStats.total}`;
+
+	const content =
+		chalk.white.bold('Project Dashboard') +
+		'\n' +
+		`Tasks Progress: ${taskProgressBar} ${chalk.yellow(taskPercentage)}\n` +
+		formatStatusLine(taskStats, false) +
+		'\n\n' +
+		`Subtasks Progress: ${subtaskProgressBar} ${chalk.cyan(subtaskPercentage)}\n` +
+		formatStatusLine(subtaskStats, true) +
+		'\n\n' +
+		chalk.cyan.bold('Priority Breakdown:') +
+		'\n' +
+		`${chalk.red('•')} ${chalk.white('High priority:')} ${priorityBreakdown.high}\n` +
+		`${chalk.yellow('•')} ${chalk.white('Medium priority:')} ${priorityBreakdown.medium}\n` +
+		`${chalk.green('•')} ${chalk.white('Low priority:')} ${priorityBreakdown.low}`;
+
+	return content;
+}
+
+/**
+ * Display the dependency dashboard box
+ */
+export function displayDependencyDashboard(
+	depStats: DependencyStatistics,
+	nextTask?: NextTaskInfo
+): string {
+	const content =
+		chalk.white.bold('Dependency Status & Next Task') +
+		'\n' +
+		chalk.cyan.bold('Dependency Metrics:') +
+		'\n' +
+		`${chalk.green('•')} ${chalk.white('Tasks with no dependencies:')} ${depStats.tasksWithNoDeps}\n` +
+		`${chalk.green('•')} ${chalk.white('Tasks ready to work on:')} ${depStats.tasksReadyToWork}\n` +
+		`${chalk.yellow('•')} ${chalk.white('Tasks blocked by dependencies:')} ${depStats.tasksBlockedByDeps}\n` +
+		`${chalk.magenta('•')} ${chalk.white('Most depended-on task:')} ${
+			depStats.mostDependedOnTaskId
+				? chalk.cyan(
+						`#${depStats.mostDependedOnTaskId} (${depStats.mostDependedOnCount} dependents)`
+					)
+				: chalk.gray('None')
+		}\n` +
+		`${chalk.blue('•')} ${chalk.white('Avg dependencies per task:')} ${depStats.avgDependenciesPerTask.toFixed(1)}\n\n` +
+		chalk.cyan.bold('Next Task to Work On:') +
+		'\n' +
+		`ID: ${nextTask ? chalk.cyan(String(nextTask.id)) : chalk.gray('N/A')} - ${
+			nextTask
+				? chalk.white.bold(nextTask.title)
+				: chalk.yellow('No task available')
+		}\n` +
+		`Priority: ${nextTask?.priority || chalk.gray('N/A')}  Dependencies: ${
+			nextTask?.dependencies?.length
+				? chalk.cyan(nextTask.dependencies.join(', '))
+				: chalk.gray('None')
+		}\n` +
+		`Complexity: ${nextTask?.complexity || chalk.gray('N/A')}`;
+
+	return content;
+}
+
+/**
+ * Display dashboard boxes side by side or stacked
+ */
+export function displayDashboards(
+	taskStats: TaskStatistics,
+	subtaskStats: TaskStatistics,
+	priorityBreakdown: Record<TaskPriority, number>,
+	depStats: DependencyStatistics,
+	nextTask?: NextTaskInfo
+): void {
+	const projectDashboardContent = displayProjectDashboard(
+		taskStats,
+		subtaskStats,
+		priorityBreakdown
+	);
+	const dependencyDashboardContent = displayDependencyDashboard(
+		depStats,
+		nextTask
+	);
+
+	// Get terminal width
+	const terminalWidth = process.stdout.columns || 80;
+	const minDashboardWidth = 50;
+	const minDependencyWidth = 50;
+	const totalMinWidth = minDashboardWidth + minDependencyWidth + 4;
+
+	// If terminal is wide enough, show side by side
+	if (terminalWidth >= totalMinWidth) {
+		const halfWidth = Math.floor(terminalWidth / 2);
+		const boxContentWidth = halfWidth - 4;
+
+		const dashboardBox = boxen(projectDashboardContent, {
+			padding: 1,
+			borderColor: 'blue',
+			borderStyle: 'round',
+			width: boxContentWidth,
+			dimBorder: false
+		});
+
+		const dependencyBox = boxen(dependencyDashboardContent, {
+			padding: 1,
+			borderColor: 'magenta',
+			borderStyle: 'round',
+			width: boxContentWidth,
+			dimBorder: false
+		});
+
+		// Create side-by-side layout
+		const dashboardLines = dashboardBox.split('\n');
+		const dependencyLines = dependencyBox.split('\n');
+		const maxHeight = Math.max(dashboardLines.length, dependencyLines.length);
+
+		const combinedLines = [];
+		for (let i = 0; i < maxHeight; i++) {
+			const dashLine = i < dashboardLines.length ? dashboardLines[i] : '';
+			const depLine = i < dependencyLines.length ? dependencyLines[i] : '';
+			const paddedDashLine = dashLine.padEnd(halfWidth, ' ');
+			combinedLines.push(paddedDashLine + depLine);
+		}
+
+		console.log(combinedLines.join('\n'));
+	} else {
+		// Show stacked vertically
+		const dashboardBox = boxen(projectDashboardContent, {
+			padding: 1,
+			borderColor: 'blue',
+			borderStyle: 'round',
+			margin: { top: 0, bottom: 1 }
+		});
+
+		const dependencyBox = boxen(dependencyDashboardContent, {
+			padding: 1,
+			borderColor: 'magenta',
+			borderStyle: 'round',
+			margin: { top: 0, bottom: 1 }
+		});
+
+		console.log(dashboardBox);
+		console.log(dependencyBox);
+	}
+}

apps/cli/src/ui/components/header.component.ts

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Task Master header component
+ * Displays the banner, version, project info, and file path
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Header configuration options
+ */
+export interface HeaderOptions {
+	title?: string;
+	tag?: string;
+	filePath?: string;
+}
+
+/**
+ * Display the Task Master header with project info
+ */
+export function displayHeader(options: HeaderOptions = {}): void {
+	const { filePath, tag } = options;
+
+	// Display tag and file path info
+	if (tag) {
+		let tagInfo = '';
+
+		if (tag && tag !== 'master') {
+			tagInfo = `🏷 tag: ${chalk.cyan(tag)}`;
+		} else {
+			tagInfo = `🏷 tag: ${chalk.cyan('master')}`;
+		}
+
+		console.log(tagInfo);
+
+		if (filePath) {
+			// Convert to absolute path if it's relative
+			const absolutePath = filePath.startsWith('/')
+				? filePath
+				: `${process.cwd()}/${filePath}`;
+			console.log(`Listing tasks from: ${chalk.dim(absolutePath)}`);
+		}
+
+		console.log(); // Empty line for spacing
+	}
+}

apps/cli/src/ui/components/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview UI components exports
+ */
+
+export * from './header.component.js';
+export * from './dashboard.component.js';
+export * from './next-task.component.js';
+export * from './suggested-steps.component.js';
+export * from './task-detail.component.js';

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

@@ -0,0 +1,134 @@
+/**
+ * @fileoverview Next task recommendation component
+ * Displays detailed information about the recommended next task
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import type { Task } from '@tm/core/types';
+
+/**
+ * Next task display options
+ */
+export interface NextTaskDisplayOptions {
+	id: string | number;
+	title: string;
+	priority?: string;
+	status?: string;
+	dependencies?: (string | number)[];
+	description?: string;
+}
+
+/**
+ * Display the recommended next task section
+ */
+export function displayRecommendedNextTask(
+	task: NextTaskDisplayOptions | undefined
+): void {
+	if (!task) {
+		// If no task available, show a message
+		console.log(
+			boxen(
+				chalk.yellow(
+					'No tasks available to work on. All tasks are either completed, blocked by dependencies, or in progress.'
+				),
+				{
+					padding: 1,
+					borderStyle: 'round',
+					borderColor: 'yellow',
+					title: '⚠ NO TASKS AVAILABLE ⚠',
+					titleAlignment: 'center'
+				}
+			)
+		);
+		return;
+	}
+
+	// Build the content for the next task box
+	const content = [];
+
+	// Task header with ID and title
+	content.push(
+		`🔥 ${chalk.hex('#FF8800').bold('Next Task to Work On:')} ${chalk.yellow(`#${task.id}`)}${chalk.hex('#FF8800').bold(` - ${task.title}`)}`
+	);
+	content.push('');
+
+	// Priority and Status line
+	const statusLine = [];
+	if (task.priority) {
+		const priorityColor =
+			task.priority === 'high'
+				? chalk.red
+				: task.priority === 'medium'
+					? chalk.yellow
+					: chalk.gray;
+		statusLine.push(`Priority: ${priorityColor.bold(task.priority)}`);
+	}
+	if (task.status) {
+		const statusDisplay =
+			task.status === 'pending'
+				? chalk.yellow('○ pending')
+				: task.status === 'in-progress'
+					? chalk.blue('▶ in-progress')
+					: chalk.gray(task.status);
+		statusLine.push(`Status: ${statusDisplay}`);
+	}
+	content.push(statusLine.join('  '));
+
+	// Dependencies
+	const depsDisplay =
+		!task.dependencies || task.dependencies.length === 0
+			? chalk.gray('None')
+			: chalk.cyan(task.dependencies.join(', '));
+	content.push(`Dependencies: ${depsDisplay}`);
+
+	// Description if available
+	if (task.description) {
+		content.push('');
+		content.push(`Description: ${chalk.white(task.description)}`);
+	}
+
+	// Action commands
+	content.push('');
+	content.push(
+		`${chalk.cyan('Start working:')} ${chalk.yellow(`task-master set-status --id=${task.id} --status=in-progress`)}`
+	);
+	content.push(
+		`${chalk.cyan('View details:')} ${chalk.yellow(`task-master show ${task.id}`)}`
+	);
+
+	// Display in a styled box with orange border
+	console.log(
+		boxen(content.join('\n'), {
+			padding: 1,
+			margin: { top: 1, bottom: 1 },
+			borderStyle: 'round',
+			borderColor: '#FFA500', // Orange color
+			title: chalk.hex('#FFA500')('⚡ RECOMMENDED NEXT TASK ⚡'),
+			titleAlignment: 'center',
+			width: process.stdout.columns * 0.97,
+			fullscreen: false
+		})
+	);
+}
+
+/**
+ * Get task description from the full task object
+ */
+export function getTaskDescription(task: Task): string | undefined {
+	// Try to get description from the task
+	// This could be from task.description or the first line of task.details
+	if ('description' in task && task.description) {
+		return task.description as string;
+	}
+
+	if ('details' in task && task.details) {
+		// Take first sentence or line from details
+		const details = task.details as string;
+		const firstLine = details.split('\n')[0];
+		const firstSentence = firstLine.split('.')[0];
+		return firstSentence;
+	}
+
+	return undefined;
+}

apps/cli/src/ui/components/suggested-steps.component.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Suggested next steps component
+ * Displays helpful command suggestions at the end of the list
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+
+/**
+ * Display suggested next steps section
+ */
+export function displaySuggestedNextSteps(): void {
+	const steps = [
+		`${chalk.cyan('1.')} Run ${chalk.yellow('task-master next')} to see what to work on next`,
+		`${chalk.cyan('2.')} Run ${chalk.yellow('task-master expand --id=<id>')} to break down a task into subtasks`,
+		`${chalk.cyan('3.')} Run ${chalk.yellow('task-master set-status --id=<id> --status=done')} to mark a task as complete`
+	];
+
+	console.log(
+		boxen(
+			chalk.white.bold('Suggested Next Steps:') + '\n\n' + steps.join('\n'),
+			{
+				padding: 1,
+				margin: { top: 0, bottom: 1 },
+				borderStyle: 'round',
+				borderColor: 'gray',
+				width: process.stdout.columns * 0.97
+			}
+		)
+	);
+}

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

@@ -0,0 +1,335 @@
+/**
+ * @fileoverview Task detail component for show command
+ * Displays detailed task information in a structured format
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import Table from 'cli-table3';
+import { marked, MarkedExtension } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import type { Task } from '@tm/core/types';
+import { getStatusWithColor, getPriorityWithColor } from '../../utils/ui.js';
+
+// Configure marked to use terminal renderer with subtle colors
+marked.use(
+	markedTerminal({
+		// More subtle colors that match the overall design
+		code: (code: string) => {
+			// Custom code block handler to preserve formatting
+			return code
+				.split('\n')
+				.map((line) => '    ' + chalk.cyan(line))
+				.join('\n');
+		},
+		blockquote: chalk.gray.italic,
+		html: chalk.gray,
+		heading: chalk.white.bold, // White bold for headings
+		hr: chalk.gray,
+		listitem: chalk.white, // White for list items
+		paragraph: chalk.white, // White for paragraphs (default text color)
+		strong: chalk.white.bold, // White bold for strong text
+		em: chalk.white.italic, // White italic for emphasis
+		codespan: chalk.cyan, // Cyan for inline code (no background)
+		del: chalk.dim.strikethrough,
+		link: chalk.blue,
+		href: chalk.blue.underline,
+		// Add more explicit code block handling
+		showSectionPrefix: false,
+		unescape: true,
+		emoji: false,
+		// Try to preserve whitespace in code blocks
+		tab: 4,
+		width: 120
+	}) as MarkedExtension
+);
+
+// Also set marked options to preserve whitespace
+marked.setOptions({
+	breaks: true,
+	gfm: true
+});
+
+/**
+ * Display the task header with tag
+ */
+export function displayTaskHeader(
+	taskId: string | number,
+	title: string
+): void {
+	// Display task header box
+	console.log(
+		boxen(chalk.white.bold(`Task: #${taskId} - ${title}`), {
+			padding: { top: 0, bottom: 0, left: 1, right: 1 },
+			borderColor: 'blue',
+			borderStyle: 'round'
+		})
+	);
+}
+
+/**
+ * Display task properties in a table format
+ */
+export function displayTaskProperties(task: Task): void {
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+	// Create table for task properties - simple 2-column layout
+	const table = new Table({
+		head: [],
+		style: {
+			head: [],
+			border: ['grey']
+		},
+		colWidths: [
+			Math.floor(terminalWidth * 0.2),
+			Math.floor(terminalWidth * 0.8)
+		],
+		wordWrap: true
+	});
+
+	const deps =
+		task.dependencies && task.dependencies.length > 0
+			? task.dependencies.map((d) => String(d)).join(', ')
+			: 'None';
+
+	// Build the left column (labels) and right column (values)
+	const labels = [
+		chalk.cyan('ID:'),
+		chalk.cyan('Title:'),
+		chalk.cyan('Status:'),
+		chalk.cyan('Priority:'),
+		chalk.cyan('Dependencies:'),
+		chalk.cyan('Complexity:'),
+		chalk.cyan('Description:')
+	].join('\n');
+
+	const values = [
+		String(task.id),
+		task.title,
+		getStatusWithColor(task.status),
+		getPriorityWithColor(task.priority),
+		deps,
+		'N/A',
+		task.description || ''
+	].join('\n');
+
+	table.push([labels, values]);
+
+	console.log(table.toString());
+}
+
+/**
+ * Display implementation details in a box
+ */
+export function displayImplementationDetails(details: string): void {
+	// Handle all escaped characters properly
+	const cleanDetails = details
+		.replace(/\\n/g, '\n') // Convert \n to actual newlines
+		.replace(/\\t/g, '\t') // Convert \t to actual tabs
+		.replace(/\\"/g, '"') // Convert \" to actual quotes
+		.replace(/\\\\/g, '\\'); // Convert \\ to single backslash
+
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+
+	// Parse markdown to terminal-friendly format
+	const markdownResult = marked(cleanDetails);
+	const formattedDetails =
+		typeof markdownResult === 'string' ? markdownResult.trim() : cleanDetails; // Fallback to original if Promise
+
+	console.log(
+		boxen(
+			chalk.white.bold('Implementation Details:') + '\n\n' + formattedDetails,
+			{
+				padding: 1,
+				borderStyle: 'round',
+				borderColor: 'cyan', // Changed to cyan to match the original
+				width: terminalWidth // Fixed width to match the original
+			}
+		)
+	);
+}
+
+/**
+ * Display test strategy in a box
+ */
+export function displayTestStrategy(testStrategy: string): void {
+	// Handle all escaped characters properly (same as implementation details)
+	const cleanStrategy = testStrategy
+		.replace(/\\n/g, '\n') // Convert \n to actual newlines
+		.replace(/\\t/g, '\t') // Convert \t to actual tabs
+		.replace(/\\"/g, '"') // Convert \" to actual quotes
+		.replace(/\\\\/g, '\\'); // Convert \\ to single backslash
+
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+
+	// Parse markdown to terminal-friendly format (same as implementation details)
+	const markdownResult = marked(cleanStrategy);
+	const formattedStrategy =
+		typeof markdownResult === 'string' ? markdownResult.trim() : cleanStrategy; // Fallback to original if Promise
+
+	console.log(
+		boxen(chalk.white.bold('Test Strategy:') + '\n\n' + formattedStrategy, {
+			padding: 1,
+			borderStyle: 'round',
+			borderColor: 'cyan', // Changed to cyan to match implementation details
+			width: terminalWidth
+		})
+	);
+}
+
+/**
+ * Display subtasks in a table format
+ */
+export function displaySubtasks(
+	subtasks: Array<{
+		id: string | number;
+		title: string;
+		status: any;
+		description?: string;
+		dependencies?: string[];
+	}>,
+	parentId: string | number
+): void {
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+	// Display subtasks header
+	console.log(
+		boxen(chalk.magenta.bold('Subtasks'), {
+			padding: { top: 0, bottom: 0, left: 1, right: 1 },
+			borderColor: 'magenta',
+			borderStyle: 'round',
+			margin: { top: 1, bottom: 0 }
+		})
+	);
+
+	// Create subtasks table
+	const table = new Table({
+		head: [
+			chalk.magenta.bold('ID'),
+			chalk.magenta.bold('Status'),
+			chalk.magenta.bold('Title'),
+			chalk.magenta.bold('Deps')
+		],
+		style: {
+			head: [],
+			border: ['grey']
+		},
+		colWidths: [
+			Math.floor(terminalWidth * 0.1),
+			Math.floor(terminalWidth * 0.15),
+			Math.floor(terminalWidth * 0.6),
+			Math.floor(terminalWidth * 0.15)
+		],
+		wordWrap: true
+	});
+
+	subtasks.forEach((subtask) => {
+		const subtaskId = `${parentId}.${subtask.id}`;
+
+		// Format dependencies
+		const deps =
+			subtask.dependencies && subtask.dependencies.length > 0
+				? subtask.dependencies.join(', ')
+				: 'None';
+
+		table.push([
+			subtaskId,
+			getStatusWithColor(subtask.status),
+			subtask.title,
+			deps
+		]);
+	});
+
+	console.log(table.toString());
+}
+
+/**
+ * Display suggested actions
+ */
+export function displaySuggestedActions(taskId: string | number): void {
+	console.log(
+		boxen(
+			chalk.white.bold('Suggested Actions:') +
+				'\n\n' +
+				`${chalk.cyan('1.')} Run ${chalk.yellow(`task-master set-status --id=${taskId} --status=in-progress`)} to start working\n` +
+				`${chalk.cyan('2.')} Run ${chalk.yellow(`task-master expand --id=${taskId}`)} to break down into subtasks\n` +
+				`${chalk.cyan('3.')} Run ${chalk.yellow(`task-master update-task --id=${taskId} --prompt="..."`)} to update details`,
+			{
+				padding: 1,
+				margin: { top: 1 },
+				borderStyle: 'round',
+				borderColor: 'green',
+				width: process.stdout.columns * 0.95 || 100
+			}
+		)
+	);
+}
+
+/**
+ * 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/ui/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Main UI exports
+ */
+
+// Export all components
+export * from './components/index.js';
+
+// Re-export existing UI utilities
+export * from '../utils/ui.js';

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

@@ -0,0 +1,240 @@
+/**
+ * @fileoverview Auto-update utilities for task-master-ai CLI
+ */
+
+import { spawn } from 'child_process';
+import https from 'https';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+
+export interface UpdateInfo {
+	currentVersion: string;
+	latestVersion: string;
+	needsUpdate: boolean;
+}
+
+/**
+ * Get current version from build-time injected environment variable
+ */
+function getCurrentVersion(): string {
+	// 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';
+}
+
+/**
+ * Compare semantic versions with proper pre-release handling
+ * @param v1 - First version
+ * @param v2 - Second version
+ * @returns -1 if v1 < v2, 0 if v1 = v2, 1 if v1 > v2
+ */
+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);
+		return { nums, pre };
+	};
+
+	const a = toParts(v1);
+	const b = toParts(v2);
+	const len = Math.max(a.nums.length, b.nums.length);
+
+	// Compare numeric parts
+	for (let i = 0; i < len; i++) {
+		const d = (a.nums[i] || 0) - (b.nums[i] || 0);
+		if (d !== 0) return d < 0 ? -1 : 1;
+	}
+
+	// Handle pre-release comparison
+	if (a.pre && !b.pre) return -1; // prerelease < release
+	if (!a.pre && b.pre) return 1; // release > prerelease
+	if (a.pre === b.pre) return 0; // same or both empty
+	return a.pre < b.pre ? -1 : 1; // basic prerelease tie-break
+}
+
+/**
+ * Check for newer version of task-master-ai
+ */
+export async function checkForUpdate(
+	currentVersionOverride?: string
+): Promise<UpdateInfo> {
+	const currentVersion = currentVersionOverride || getCurrentVersion();
+
+	return new Promise((resolve) => {
+		const options = {
+			hostname: 'registry.npmjs.org',
+			path: '/task-master-ai',
+			method: 'GET',
+			headers: {
+				Accept: 'application/vnd.npm.install-v1+json',
+				'User-Agent': `task-master-ai/${currentVersion}`
+			}
+		};
+
+		const req = https.request(options, (res) => {
+			let data = '';
+
+			res.on('data', (chunk) => {
+				data += chunk;
+			});
+
+			res.on('end', () => {
+				try {
+					if (res.statusCode !== 200)
+						throw new Error(`npm registry status ${res.statusCode}`);
+					const npmData = JSON.parse(data);
+					const latestVersion = npmData['dist-tags']?.latest || currentVersion;
+
+					const needsUpdate =
+						compareVersions(currentVersion, latestVersion) < 0;
+
+					resolve({
+						currentVersion,
+						latestVersion,
+						needsUpdate
+					});
+				} catch (error) {
+					resolve({
+						currentVersion,
+						latestVersion: currentVersion,
+						needsUpdate: false
+					});
+				}
+			});
+		});
+
+		req.on('error', () => {
+			resolve({
+				currentVersion,
+				latestVersion: currentVersion,
+				needsUpdate: false
+			});
+		});
+
+		req.setTimeout(3000, () => {
+			req.destroy();
+			resolve({
+				currentVersion,
+				latestVersion: currentVersion,
+				needsUpdate: false
+			});
+		});
+
+		req.end();
+	});
+}
+
+/**
+ * Display upgrade notification message
+ */
+export function displayUpgradeNotification(
+	currentVersion: string,
+	latestVersion: string
+) {
+	const message = boxen(
+		`${chalk.blue.bold('Update Available!')} ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}\n\n` +
+			`Auto-updating to the latest version with new features and bug fixes...`,
+		{
+			padding: 1,
+			margin: { top: 1, bottom: 1 },
+			borderColor: 'yellow',
+			borderStyle: 'round'
+		}
+	);
+
+	console.log(message);
+}
+
+/**
+ * Automatically update task-master-ai to the latest version
+ */
+export async function performAutoUpdate(
+	latestVersion: string
+): Promise<boolean> {
+	if (process.env.TASKMASTER_SKIP_AUTO_UPDATE === '1' || process.env.CI) {
+		console.log(
+			chalk.dim('Skipping auto-update (TASKMASTER_SKIP_AUTO_UPDATE/CI).')
+		);
+		return false;
+	}
+	const spinner = ora({
+		text: chalk.blue(
+			`Updating task-master-ai to version ${chalk.green(latestVersion)}`
+		),
+		spinner: 'dots',
+		color: 'blue'
+	}).start();
+
+	return new Promise((resolve) => {
+		const updateProcess = spawn(
+			'npm',
+			[
+				'install',
+				'-g',
+				`task-master-ai@${latestVersion}`,
+				'--no-fund',
+				'--no-audit',
+				'--loglevel=warn'
+			],
+			{
+				stdio: ['ignore', 'pipe', 'pipe']
+			}
+		);
+
+		let errorOutput = '';
+
+		updateProcess.stdout.on('data', () => {
+			// Update spinner text with progress
+			spinner.text = chalk.blue(
+				`Installing task-master-ai@${latestVersion}...`
+			);
+		});
+
+		updateProcess.stderr.on('data', (data) => {
+			errorOutput += data.toString();
+		});
+
+		updateProcess.on('close', (code) => {
+			if (code === 0) {
+				spinner.succeed(
+					chalk.green(
+						`Successfully updated to version ${chalk.bold(latestVersion)}`
+					)
+				);
+				console.log(
+					chalk.dim('Please restart your command to use the new version.')
+				);
+				resolve(true);
+			} else {
+				spinner.fail(chalk.red('Auto-update failed'));
+				console.log(
+					chalk.cyan(
+						`Please run manually: npm install -g task-master-ai@${latestVersion}`
+					)
+				);
+				if (errorOutput) {
+					console.log(chalk.dim(`Error: ${errorOutput.trim()}`));
+				}
+				resolve(false);
+			}
+		});
+
+		updateProcess.on('error', (error) => {
+			spinner.fail(chalk.red('Auto-update failed'));
+			console.log(chalk.red('Error:'), error.message);
+			console.log(
+				chalk.cyan(
+					`Please run manually: npm install -g task-master-ai@${latestVersion}`
+				)
+			);
+			resolve(false);
+		});
+	});
+}

apps/cli/src/utils/ui.ts

@@ -0,0 +1,362 @@
+/**
+ * @fileoverview UI utilities for Task Master CLI
+ * Provides formatting, display, and visual components for the command line interface
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import Table from 'cli-table3';
+import type { Task, TaskStatus, TaskPriority } from '@tm/core/types';
+
+/**
+ * Get colored status display with ASCII icons (matches scripts/modules/ui.js style)
+ */
+export function getStatusWithColor(
+	status: TaskStatus,
+	forTable: boolean = false
+): string {
+	const statusConfig = {
+		done: {
+			color: chalk.green,
+			icon: '✓',
+			tableIcon: '✓'
+		},
+		pending: {
+			color: chalk.yellow,
+			icon: '○',
+			tableIcon: '○'
+		},
+		'in-progress': {
+			color: chalk.hex('#FFA500'),
+			icon: '▶',
+			tableIcon: '▶'
+		},
+		deferred: {
+			color: chalk.gray,
+			icon: 'x',
+			tableIcon: 'x'
+		},
+		review: {
+			color: chalk.magenta,
+			icon: '?',
+			tableIcon: '?'
+		},
+		cancelled: {
+			color: chalk.gray,
+			icon: 'x',
+			tableIcon: 'x'
+		},
+		blocked: {
+			color: chalk.red,
+			icon: '!',
+			tableIcon: '!'
+		},
+		completed: {
+			color: chalk.green,
+			icon: '✓',
+			tableIcon: '✓'
+		}
+	};
+
+	const config = statusConfig[status] || {
+		color: chalk.red,
+		icon: 'X',
+		tableIcon: 'X'
+	};
+
+	const icon = forTable ? config.tableIcon : config.icon;
+	return config.color(`${icon} ${status}`);
+}
+
+/**
+ * Get colored priority display
+ */
+export function getPriorityWithColor(priority: TaskPriority): string {
+	const priorityColors: Record<TaskPriority, (text: string) => string> = {
+		critical: chalk.red.bold,
+		high: chalk.red,
+		medium: chalk.yellow,
+		low: chalk.gray
+	};
+
+	const colorFn = priorityColors[priority] || chalk.white;
+	return colorFn(priority);
+}
+
+/**
+ * Get colored complexity display
+ */
+export function getComplexityWithColor(complexity: number | string): string {
+	const score =
+		typeof complexity === 'string' ? parseInt(complexity, 10) : complexity;
+
+	if (isNaN(score)) {
+		return chalk.gray('N/A');
+	}
+
+	if (score >= 8) {
+		return chalk.red.bold(`${score} (High)`);
+	} else if (score >= 5) {
+		return chalk.yellow(`${score} (Medium)`);
+	} else {
+		return chalk.green(`${score} (Low)`);
+	}
+}
+
+/**
+ * Truncate text to specified length
+ */
+export function truncate(text: string, maxLength: number): string {
+	if (text.length <= maxLength) {
+		return text;
+	}
+	return text.substring(0, maxLength - 3) + '...';
+}
+
+/**
+ * Create a progress bar
+ */
+export function createProgressBar(
+	completed: number,
+	total: number,
+	width: number = 30
+): string {
+	if (total === 0) {
+		return chalk.gray('No tasks');
+	}
+
+	const percentage = Math.round((completed / total) * 100);
+	const filled = Math.round((completed / total) * width);
+	const empty = width - filled;
+
+	const bar = chalk.green('█').repeat(filled) + chalk.gray('░').repeat(empty);
+
+	return `${bar} ${chalk.cyan(`${percentage}%`)} (${completed}/${total})`;
+}
+
+/**
+ * Display a fancy banner
+ */
+export function displayBanner(title: string = 'Task Master'): void {
+	console.log(
+		boxen(chalk.white.bold(title), {
+			padding: 1,
+			margin: { top: 1, bottom: 1 },
+			borderStyle: 'round',
+			borderColor: 'blue',
+			textAlignment: 'center'
+		})
+	);
+}
+
+/**
+ * Display an error message (matches scripts/modules/ui.js style)
+ */
+export function displayError(message: string, details?: string): void {
+	console.error(
+		boxen(
+			chalk.red.bold('X Error: ') +
+				chalk.white(message) +
+				(details ? '\n\n' + chalk.gray(details) : ''),
+			{
+				padding: 1,
+				borderStyle: 'round',
+				borderColor: 'red'
+			}
+		)
+	);
+}
+
+/**
+ * Display a success message
+ */
+export function displaySuccess(message: string): void {
+	console.log(
+		boxen(
+			chalk.green.bold(String.fromCharCode(8730) + ' ') + chalk.white(message),
+			{
+				padding: 1,
+				borderStyle: 'round',
+				borderColor: 'green'
+			}
+		)
+	);
+}
+
+/**
+ * Display a warning message
+ */
+export function displayWarning(message: string): void {
+	console.log(
+		boxen(chalk.yellow.bold('⚠ ') + chalk.white(message), {
+			padding: 1,
+			borderStyle: 'round',
+			borderColor: 'yellow'
+		})
+	);
+}
+
+/**
+ * Display info message
+ */
+export function displayInfo(message: string): void {
+	console.log(
+		boxen(chalk.blue.bold('i ') + chalk.white(message), {
+			padding: 1,
+			borderStyle: 'round',
+			borderColor: 'blue'
+		})
+	);
+}
+
+/**
+ * Format dependencies with their status
+ */
+export function formatDependenciesWithStatus(
+	dependencies: string[] | number[],
+	tasks: Task[]
+): string {
+	if (!dependencies || dependencies.length === 0) {
+		return chalk.gray('none');
+	}
+
+	const taskMap = new Map(tasks.map((t) => [t.id.toString(), t]));
+
+	return dependencies
+		.map((depId) => {
+			const task = taskMap.get(depId.toString());
+			if (!task) {
+				return chalk.red(`${depId} (not found)`);
+			}
+
+			const statusIcon =
+				task.status === 'done'
+					? '✓'
+					: task.status === 'in-progress'
+						? '►'
+						: '○';
+
+			return `${depId}${statusIcon}`;
+		})
+		.join(', ');
+}
+
+/**
+ * Create a task table for display
+ */
+export function createTaskTable(
+	tasks: Task[],
+	options?: {
+		showSubtasks?: boolean;
+		showComplexity?: boolean;
+		showDependencies?: boolean;
+	}
+): string {
+	const {
+		showSubtasks = false,
+		showComplexity = false,
+		showDependencies = true
+	} = options || {};
+
+	// Calculate dynamic column widths based on terminal width
+	const terminalWidth = process.stdout.columns * 0.9 || 100;
+	// Adjust column widths to better match the original layout
+	const baseColWidths = showComplexity
+		? [
+				Math.floor(terminalWidth * 0.06),
+				Math.floor(terminalWidth * 0.4),
+				Math.floor(terminalWidth * 0.15),
+				Math.floor(terminalWidth * 0.12),
+				Math.floor(terminalWidth * 0.2),
+				Math.floor(terminalWidth * 0.12)
+			] // ID, Title, Status, Priority, Dependencies, Complexity
+		: [
+				Math.floor(terminalWidth * 0.08),
+				Math.floor(terminalWidth * 0.4),
+				Math.floor(terminalWidth * 0.18),
+				Math.floor(terminalWidth * 0.12),
+				Math.floor(terminalWidth * 0.2)
+			]; // ID, Title, Status, Priority, Dependencies
+
+	const headers = [
+		chalk.blue.bold('ID'),
+		chalk.blue.bold('Title'),
+		chalk.blue.bold('Status'),
+		chalk.blue.bold('Priority')
+	];
+	const colWidths = baseColWidths.slice(0, 4);
+
+	if (showDependencies) {
+		headers.push(chalk.blue.bold('Dependencies'));
+		colWidths.push(baseColWidths[4]);
+	}
+
+	if (showComplexity) {
+		headers.push(chalk.blue.bold('Complexity'));
+		colWidths.push(baseColWidths[5] || 12);
+	}
+
+	const table = new Table({
+		head: headers,
+		style: { head: [], border: [] },
+		colWidths,
+		wordWrap: true
+	});
+
+	tasks.forEach((task) => {
+		const row: string[] = [
+			chalk.cyan(task.id.toString()),
+			truncate(task.title, colWidths[1] - 3),
+			getStatusWithColor(task.status, true), // Use table version
+			getPriorityWithColor(task.priority)
+		];
+
+		if (showDependencies) {
+			// For table display, show simple format without status icons
+			if (!task.dependencies || task.dependencies.length === 0) {
+				row.push(chalk.gray('None'));
+			} else {
+				row.push(
+					chalk.cyan(task.dependencies.map((d) => String(d)).join(', '))
+				);
+			}
+		}
+
+		if (showComplexity) {
+			// Show N/A if no complexity score
+			row.push(chalk.gray('N/A'));
+		}
+
+		table.push(row);
+
+		// Add subtasks if requested
+		if (showSubtasks && task.subtasks && task.subtasks.length > 0) {
+			task.subtasks.forEach((subtask) => {
+				const subRow: string[] = [
+					chalk.gray(` └─ ${subtask.id}`),
+					chalk.gray(truncate(subtask.title, colWidths[1] - 6)),
+					chalk.gray(getStatusWithColor(subtask.status, true)),
+					chalk.gray(subtask.priority || 'medium')
+				];
+
+				if (showDependencies) {
+					subRow.push(
+						chalk.gray(
+							subtask.dependencies && subtask.dependencies.length > 0
+								? subtask.dependencies.map((dep) => String(dep)).join(', ')
+								: 'None'
+						)
+					);
+				}
+
+				if (showComplexity) {
+					subRow.push(chalk.gray('--'));
+				}
+
+				table.push(subRow);
+			});
+		}
+	});
+
+	return table.toString();
+}

apps/cli/tsconfig.json

@@ -0,0 +1,36 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"lib": ["ES2022"],
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"outDir": "./dist",
+		"baseUrl": ".",
+		"rootDir": "./src",
+		"strict": true,
+		"noImplicitAny": true,
+		"strictNullChecks": true,
+		"strictFunctionTypes": true,
+		"strictBindCallApply": true,
+		"strictPropertyInitialization": true,
+		"noImplicitThis": true,
+		"alwaysStrict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"moduleResolution": "NodeNext",
+		"moduleDetection": "force",
+		"types": ["node"],
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"allowImportingTsExtensions": false
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
+}

apps/docs/CHANGELOG.md

@@ -0,0 +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/best-practices/configuration-advanced.mdx

@@ -83,6 +83,8 @@ Taskmaster uses two primary methods for configuration:
   - `VERTEX_PROJECT_ID`: Your Google Cloud project ID for Vertex AI. Required when using the 'vertex' provider.
   - `VERTEX_LOCATION`: Google Cloud region for Vertex AI (e.g., 'us-central1'). Default is 'us-central1'.
   - `GOOGLE_APPLICATION_CREDENTIALS`: Path to service account credentials JSON file for Google Cloud auth (alternative to API key for Vertex AI).
+- **Optional Auto-Update Control:**
+  - `TASKMASTER_SKIP_AUTO_UPDATE`: Set to '1' to disable automatic updates. Also automatically disabled in CI environments (when `CI` environment variable is set).
 
 **Important:** Settings like model ID selections (`main`, `research`, `fallback`), `maxTokens`, `temperature`, `logLevel`, `defaultSubtasks`, `defaultPriority`, and `projectName` are **managed in `.taskmaster/config.json`** (or `.taskmasterconfig` for unmigrated projects), not environment variables.
 

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,7 @@ 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`)
 
@@ -84,7 +84,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/package.json

@@ -1,14 +1,13 @@
 {
 	"name": "docs",
-	"version": "0.0.0",
+	"version": "0.0.4",
 	"private": true,
 	"description": "Task Master documentation powered by Mintlify",
 	"scripts": {
 		"dev": "mintlify dev",
-		"build": "mintlify build",
 		"preview": "mintlify preview"
 	},
 	"devDependencies": {
-		"mintlify": "^4.0.0"
+		"mintlify": "^4.2.111"
 	}
 }

apps/extension/CHANGELOG.md

@@ -1,5 +1,113 @@
 # Change Log
 
+## 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
+
+- [#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
+
+- Updated dependencies [[`137ef36`](https://github.com/eyaltoledano/claude-task-master/commit/137ef362789a9cdfdb1925e35e0438c1fa6c69ee)]:
+  - task-master-ai@0.27.0-rc.0
+
+## 0.24.2
+
+### Patch Changes
+
+- Updated dependencies [[`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f), [`df26c65`](https://github.com/eyaltoledano/claude-task-master/commit/df26c65632000874a73504963b08f18c46283144), [`37af0f1`](https://github.com/eyaltoledano/claude-task-master/commit/37af0f191227a68d119b7f89a377bf932ee3ac66), [`c4f92f6`](https://github.com/eyaltoledano/claude-task-master/commit/c4f92f6a0aee3435c56eb8d27d9aa9204284833e), [`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f), [`4dad2fd`](https://github.com/eyaltoledano/claude-task-master/commit/4dad2fd613ceac56a65ae9d3c1c03092b8860ac9)]:
+  - task-master-ai@0.26.0
+
+## 0.24.2-rc.1
+
+### Patch Changes
+
+- Updated dependencies [[`c4f92f6`](https://github.com/eyaltoledano/claude-task-master/commit/c4f92f6a0aee3435c56eb8d27d9aa9204284833e)]:
+  - task-master-ai@0.26.0-rc.1
+
+## 0.24.2-rc.0
+
+### Patch Changes
+
+- Updated dependencies [[`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f), [`37af0f1`](https://github.com/eyaltoledano/claude-task-master/commit/37af0f191227a68d119b7f89a377bf932ee3ac66), [`8783708`](https://github.com/eyaltoledano/claude-task-master/commit/8783708e5e3389890a78fcf685d3da0580e73b3f), [`4dad2fd`](https://github.com/eyaltoledano/claude-task-master/commit/4dad2fd613ceac56a65ae9d3c1c03092b8860ac9)]:
+  - task-master-ai@0.26.0-rc.0
+
+## 0.24.1
+
+### Patch Changes
+
+- Updated dependencies [[`8933557`](https://github.com/eyaltoledano/claude-task-master/commit/89335578ffffc65504b2055c0c85aa7521e5e79b), [`db720a9`](https://github.com/eyaltoledano/claude-task-master/commit/db720a954d390bb44838cd021b8813dde8f3d8de)]:
+  - task-master-ai@0.25.1
+
+## 0.24.0
+
+### Minor Changes
+
+- [#1100](https://github.com/eyaltoledano/claude-task-master/pull/1100) [`30ca144`](https://github.com/eyaltoledano/claude-task-master/commit/30ca144231c36a6c63911f20adc225d38fb15a2f) Thanks [@vedovelli](https://github.com/vedovelli)! - Display current task ID on task details page
+
+### Patch Changes
+
+- Updated dependencies [[`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8), [`fc47714`](https://github.com/eyaltoledano/claude-task-master/commit/fc477143400fd11d953727bf1b4277af5ad308d1), [`782728f`](https://github.com/eyaltoledano/claude-task-master/commit/782728ff95aa2e3b766d48273b57f6c6753e8573), [`3dee60d`](https://github.com/eyaltoledano/claude-task-master/commit/3dee60dc3d566e3cff650accb30f994b8bb3a15e), [`e3ed4d7`](https://github.com/eyaltoledano/claude-task-master/commit/e3ed4d7c14b56894d7da675eb2b757423bea8f9d), [`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8), [`95640dc`](https://github.com/eyaltoledano/claude-task-master/commit/95640dcde87ce7879858c0a951399fb49f3b6397), [`311b243`](https://github.com/eyaltoledano/claude-task-master/commit/311b2433e23c771c8d3a4d3f5ac577302b8321e5)]:
+  - task-master-ai@0.25.0
+
+## 0.24.0-rc.0
+
+### Minor Changes
+
+- [#1040](https://github.com/eyaltoledano/claude-task-master/pull/1040) [`fc47714`](https://github.com/eyaltoledano/claude-task-master/commit/fc477143400fd11d953727bf1b4277af5ad308d1) Thanks [@DomVidja](https://github.com/DomVidja)! - "Add Kilo Code profile integration with custom modes and MCP configuration"
+
+- [#1100](https://github.com/eyaltoledano/claude-task-master/pull/1100) [`30ca144`](https://github.com/eyaltoledano/claude-task-master/commit/30ca144231c36a6c63911f20adc225d38fb15a2f) Thanks [@vedovelli](https://github.com/vedovelli)! - Display current task ID on task details page
+
+### Patch Changes
+
+- Updated dependencies [[`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8), [`fc47714`](https://github.com/eyaltoledano/claude-task-master/commit/fc477143400fd11d953727bf1b4277af5ad308d1), [`782728f`](https://github.com/eyaltoledano/claude-task-master/commit/782728ff95aa2e3b766d48273b57f6c6753e8573), [`3dee60d`](https://github.com/eyaltoledano/claude-task-master/commit/3dee60dc3d566e3cff650accb30f994b8bb3a15e), [`e3ed4d7`](https://github.com/eyaltoledano/claude-task-master/commit/e3ed4d7c14b56894d7da675eb2b757423bea8f9d), [`04e11b5`](https://github.com/eyaltoledano/claude-task-master/commit/04e11b5e828597c0ba5b82ca7d5fb6f933e4f1e8), [`95640dc`](https://github.com/eyaltoledano/claude-task-master/commit/95640dcde87ce7879858c0a951399fb49f3b6397), [`311b243`](https://github.com/eyaltoledano/claude-task-master/commit/311b2433e23c771c8d3a4d3f5ac577302b8321e5)]:
+  - task-master-ai@0.25.0-rc.0
+
 ## 0.23.1
 
 ### Patch 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/esbuild.js

@@ -103,8 +103,8 @@ async function main() {
 		// This prevents the multiple React instances issue
 		// Ensure React is resolved from the workspace root to avoid duplicates
 		alias: {
-			react: path.resolve(__dirname, 'node_modules/react'),
-			'react-dom': path.resolve(__dirname, 'node_modules/react-dom')
+			react: path.resolve(__dirname, '../../node_modules/react'),
+			'react-dom': path.resolve(__dirname, '../../node_modules/react-dom')
 		},
 		define: {
 			'process.env.NODE_ENV': production ? '"production"' : '"development"',
@@ -135,8 +135,8 @@ async function main() {
 		jsxImportSource: 'react',
 		external: ['*.css'],
 		alias: {
-			react: path.resolve(__dirname, 'node_modules/react'),
-			'react-dom': path.resolve(__dirname, 'node_modules/react-dom')
+			react: path.resolve(__dirname, '../../node_modules/react'),
+			'react-dom': path.resolve(__dirname, '../../node_modules/react-dom')
 		},
 		define: {
 			'process.env.NODE_ENV': production ? '"production"' : '"development"',

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.23.1",
+	"version": "0.25.3",
 	"publisher": "Hamster",
 	"icon": "assets/icon.png",
 	"engines": {
@@ -229,6 +229,7 @@
 		"build": "npm run build:js && npm run build:css",
 		"build:js": "node ./esbuild.js --production",
 		"build:css": "npx @tailwindcss/cli -i ./src/webview/index.css -o ./dist/index.css --minify",
+		"dev": "npm run watch",
 		"package": "npm exec node ./package.mjs",
 		"package:direct": "node ./package.mjs",
 		"debug:env": "node ./debug-env.mjs",
@@ -239,7 +240,7 @@
 		"check-types": "tsc --noEmit"
 	},
 	"dependencies": {
-		"task-master-ai": "0.24.0"
+		"task-master-ai": "0.27.2"
 	},
 	"devDependencies": {
 		"@dnd-kit/core": "^6.3.1",
@@ -253,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",
@@ -270,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

@@ -1,16 +1,16 @@
 import type React from 'react';
 import { useState, useEffect } from 'react';
 import { Button } from '@/components/ui/button';
-import { Loader2 } from 'lucide-react';
+import { Loader2, Play } from 'lucide-react';
 import { PriorityBadge } from './PriorityBadge';
 import type { TaskMasterTask } from '../../webview/types';
+import { useVSCodeContext } from '../../webview/contexts/VSCodeContext';
 
 interface TaskMetadataSidebarProps {
 	currentTask: TaskMasterTask;
 	tasks: TaskMasterTask[];
 	complexity: any;
 	isSubtask: boolean;
-	sendMessage: (message: any) => Promise<any>;
 	onStatusChange: (status: TaskMasterTask['status']) => void;
 	onDependencyClick: (depId: string) => void;
 	isRegenerating?: boolean;
@@ -22,16 +22,17 @@ export const TaskMetadataSidebar: React.FC<TaskMetadataSidebarProps> = ({
 	tasks,
 	complexity,
 	isSubtask,
-	sendMessage,
 	onStatusChange,
 	onDependencyClick,
 	isRegenerating = false,
 	isAppending = false
 }) => {
+	const { sendMessage } = useVSCodeContext();
 	const [isLoadingComplexity, setIsLoadingComplexity] = useState(false);
 	const [mcpComplexityScore, setMcpComplexityScore] = useState<
 		number | undefined
 	>(undefined);
+	const [isStartingTask, setIsStartingTask] = useState(false);
 
 	// Get complexity score from task
 	const currentComplexityScore = complexity?.score;
@@ -97,6 +98,40 @@ export const TaskMetadataSidebar: React.FC<TaskMetadataSidebarProps> = ({
 		}
 	};
 
+	// Handle starting a task
+	const handleStartTask = async () => {
+		if (!currentTask || isStartingTask) {
+			return;
+		}
+
+		setIsStartingTask(true);
+
+		try {
+			// Send message to extension to open terminal
+			const result = await sendMessage({
+				type: 'openTerminal',
+				data: {
+					taskId: currentTask.id,
+					taskTitle: currentTask.title
+				}
+			});
+
+			// 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);
+		}
+	};
+
 	// Effect to handle complexity on task change
 	useEffect(() => {
 		if (currentTask?.id) {
@@ -284,6 +319,30 @@ export const TaskMetadataSidebar: React.FC<TaskMetadataSidebarProps> = ({
 					{currentTask.dependencies && currentTask.dependencies.length > 0 && (
 						<div className="border-b border-textSeparator-foreground" />
 					)}
+
+					{/* Start Task Button */}
+					<div className="mt-4">
+						<Button
+							onClick={handleStartTask}
+							variant="default"
+							size="sm"
+							className="w-full text-xs"
+							disabled={
+								isRegenerating ||
+								isAppending ||
+								isStartingTask ||
+								currentTask?.status === 'done' ||
+								currentTask?.status === 'in-progress'
+							}
+						>
+							{isStartingTask ? (
+								<Loader2 className="w-4 h-4 mr-2 animate-spin" />
+							) : (
+								<Play className="w-4 h-4 mr-2" />
+							)}
+							{isStartingTask ? 'Starting...' : 'Start Task'}
+						</Button>
+					</div>
 				</div>
 			</div>
 		</div>

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 {
@@ -361,6 +363,70 @@ export class WebviewManager {
 					}
 					return;
 
+				case 'openTerminal':
+					// Delegate terminal execution to TerminalManager
+					const { taskId, taskTitle } = data.data || data; // Handle both nested and direct data
+					this.logger.log(
+						`Webview openTerminal - taskId: ${taskId} (type: ${typeof taskId}), taskTitle: ${taskTitle}`
+					);
+
+					// 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
+							});
+
+							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:
 					throw new Error(`Unknown message type: ${type}`);
 			}

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",

assets/claude/commands/tm/remove-subtasks/remove-all-subtasks.md

@@ -0,0 +1,93 @@
+Clear all subtasks from all tasks globally.
+
+## Global Subtask Clearing
+
+Remove all subtasks across the entire project. Use with extreme caution.
+
+## Execution
+
+```bash
+task-master clear-subtasks --all
+```
+
+## Pre-Clear Analysis
+
+1. **Project-Wide Summary**
+   ```
+   Global Subtask Summary
+   ━━━━━━━━━━━━━━━━━━━━
+   Total parent tasks: 12
+   Total subtasks: 47
+   - Completed: 15
+   - In-progress: 8
+   - Pending: 24
+   
+   Work at risk: ~120 hours
+   ```
+
+2. **Critical Warnings**
+   - In-progress subtasks that will lose work
+   - Completed subtasks with valuable history
+   - Complex dependency chains
+   - Integration test results
+
+## Double Confirmation
+
+```
+⚠️  DESTRUCTIVE OPERATION WARNING ⚠️
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+This will remove ALL 47 subtasks from your project
+Including 8 in-progress and 15 completed subtasks
+
+This action CANNOT be undone
+
+Type 'CLEAR ALL SUBTASKS' to confirm:
+```
+
+## Smart Safeguards
+
+- Require explicit confirmation phrase
+- Create automatic backup
+- Log all removed data
+- Option to export first
+
+## Use Cases
+
+Valid reasons for global clear:
+- Project restructuring
+- Major pivot in approach
+- Starting fresh breakdown
+- Switching to different task organization
+
+## Process
+
+1. Full project analysis
+2. Create backup file
+3. Show detailed impact
+4. Require confirmation
+5. Execute removal
+6. Generate summary report
+
+## Alternative Suggestions
+
+Before clearing all:
+- Export subtasks to file
+- Clear only pending subtasks
+- Clear by task category
+- Archive instead of delete
+
+## Post-Clear Report
+
+```
+Global Subtask Clear Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Removed: 47 subtasks from 12 tasks
+Backup saved: .taskmaster/backup/subtasks-20240115.json
+Parent tasks updated: 12
+Time estimates adjusted: Yes
+
+Next steps:
+- Review updated task list
+- Re-expand complex tasks as needed
+- Check project timeline
+```

assets/claude/commands/tm/remove-subtasks/remove-subtasks.md

@@ -0,0 +1,86 @@
+Clear all subtasks from a specific task.
+
+Arguments: $ARGUMENTS (task ID)
+
+Remove all subtasks from a parent task at once.
+
+## Clearing Subtasks
+
+Bulk removal of all subtasks from a parent task.
+
+## Execution
+
+```bash
+task-master clear-subtasks --id=<task-id>
+```
+
+## Pre-Clear Analysis
+
+1. **Subtask Summary**
+   - Number of subtasks
+   - Completion status of each
+   - Work already done
+   - Dependencies affected
+
+2. **Impact Assessment**
+   - Data that will be lost
+   - Dependencies to be removed
+   - Effect on project timeline
+   - Parent task implications
+
+## Confirmation Required
+
+```
+Clear Subtasks Confirmation
+━━━━━━━━━━━━━━━━━━━━━━━━━
+Parent Task: #5 "Implement user authentication"
+Subtasks to remove: 4
+- #5.1 "Setup auth framework" (done)
+- #5.2 "Create login form" (in-progress)
+- #5.3 "Add validation" (pending)
+- #5.4 "Write tests" (pending)
+
+⚠️  This will permanently delete all subtask data
+Continue? (y/n)
+```
+
+## Smart Features
+
+- Option to convert to standalone tasks
+- Backup task data before clearing
+- Preserve completed work history
+- Update parent task appropriately
+
+## Process
+
+1. List all subtasks for confirmation
+2. Check for in-progress work
+3. Remove all subtasks
+4. Update parent task
+5. Clean up dependencies
+
+## Alternative Options
+
+Suggest alternatives:
+- Convert important subtasks to tasks
+- Keep completed subtasks
+- Archive instead of delete
+- Export subtask data first
+
+## Post-Clear
+
+- Show updated parent task
+- Recalculate time estimates
+- Update task complexity
+- Suggest next steps
+
+## Example
+
+```
+/project:tm/clear-subtasks 5
+→ Found 4 subtasks to remove
+→ Warning: Subtask #5.2 is in-progress
+→ Cleared all subtasks from task #5
+→ Updated parent task estimates
+→ Suggestion: Consider re-expanding with better breakdown
+```

bin/task-master.js

@@ -20,357 +20,8 @@
  * Main entry point for globally installed package
  */
 
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-import { createRequire } from 'module';
-import { spawn } from 'child_process';
-import { Command } from 'commander';
-import { displayHelp, displayBanner } from '../scripts/modules/ui.js';
-import { registerCommands } from '../scripts/modules/commands.js';
-import { detectCamelCaseFlags } from '../scripts/modules/utils.js';
-import chalk from 'chalk';
+// Direct imports instead of spawning child processes
+import { runCLI } from '../scripts/modules/commands.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const require = createRequire(import.meta.url);
-
-// Get package information
-const packageJson = require('../package.json');
-const version = packageJson.version;
-
-// Get paths to script files
-const devScriptPath = resolve(__dirname, '../scripts/dev.js');
-const initScriptPath = resolve(__dirname, '../scripts/init.js');
-
-// Helper function to run dev.js with arguments
-function runDevScript(args) {
-	// Debug: Show the transformed arguments when DEBUG=1 is set
-	if (process.env.DEBUG === '1') {
-		console.error('\nDEBUG - CLI Wrapper Analysis:');
-		console.error('- Original command: ' + process.argv.join(' '));
-		console.error('- Transformed args: ' + args.join(' '));
-		console.error(
-			'- dev.js will receive: node ' +
-				devScriptPath +
-				' ' +
-				args.join(' ') +
-				'\n'
-		);
-	}
-
-	// For testing: If TEST_MODE is set, just print args and exit
-	if (process.env.TEST_MODE === '1') {
-		console.log('Would execute:');
-		console.log(`node ${devScriptPath} ${args.join(' ')}`);
-		process.exit(0);
-		return;
-	}
-
-	const child = spawn('node', [devScriptPath, ...args], {
-		stdio: 'inherit',
-		cwd: process.cwd()
-	});
-
-	child.on('close', (code) => {
-		process.exit(code);
-	});
-}
-
-// Helper function to detect camelCase and convert to kebab-case
-const toKebabCase = (str) => str.replace(/([A-Z])/g, '-$1').toLowerCase();
-
-/**
- * Create a wrapper action that passes the command to dev.js
- * @param {string} commandName - The name of the command
- * @returns {Function} Wrapper action function
- */
-function createDevScriptAction(commandName) {
-	return (options, cmd) => {
-		// Check for camelCase flags and error out with helpful message
-		const camelCaseFlags = detectCamelCaseFlags(process.argv);
-
-		// If camelCase flags were found, show error and exit
-		if (camelCaseFlags.length > 0) {
-			console.error('\nError: Please use kebab-case for CLI flags:');
-			camelCaseFlags.forEach((flag) => {
-				console.error(`  Instead of: --${flag.original}`);
-				console.error(`  Use:        --${flag.kebabCase}`);
-			});
-			console.error(
-				'\nExample: task-master parse-prd --num-tasks=5 instead of --numTasks=5\n'
-			);
-			process.exit(1);
-		}
-
-		// Since we've ensured no camelCase flags, we can now just:
-		// 1. Start with the command name
-		const args = [commandName];
-
-		// 3. Get positional arguments and explicit flags from the command line
-		const commandArgs = [];
-		const positionals = new Set(); // Track positional args we've seen
-
-		// Find the command in raw process.argv to extract args
-		const commandIndex = process.argv.indexOf(commandName);
-		if (commandIndex !== -1) {
-			// Process all args after the command name
-			for (let i = commandIndex + 1; i < process.argv.length; i++) {
-				const arg = process.argv[i];
-
-				if (arg.startsWith('--')) {
-					// It's a flag - pass through as is
-					commandArgs.push(arg);
-					// Skip the next arg if this is a flag with a value (not --flag=value format)
-					if (
-						!arg.includes('=') &&
-						i + 1 < process.argv.length &&
-						!process.argv[i + 1].startsWith('--')
-					) {
-						commandArgs.push(process.argv[++i]);
-					}
-				} else if (!positionals.has(arg)) {
-					// It's a positional argument we haven't seen
-					commandArgs.push(arg);
-					positionals.add(arg);
-				}
-			}
-		}
-
-		// Add all command line args we collected
-		args.push(...commandArgs);
-
-		// 4. Add default options from Commander if not specified on command line
-		// Track which options we've seen on the command line
-		const userOptions = new Set();
-		for (const arg of commandArgs) {
-			if (arg.startsWith('--')) {
-				// Extract option name (without -- and value)
-				const name = arg.split('=')[0].slice(2);
-				userOptions.add(name);
-
-				// Add the kebab-case version too, to prevent duplicates
-				const kebabName = name.replace(/([A-Z])/g, '-$1').toLowerCase();
-				userOptions.add(kebabName);
-
-				// Add the camelCase version as well
-				const camelName = kebabName.replace(/-([a-z])/g, (_, letter) =>
-					letter.toUpperCase()
-				);
-				userOptions.add(camelName);
-			}
-		}
-
-		// Add Commander-provided defaults for options not specified by user
-		Object.entries(options).forEach(([key, value]) => {
-			// Debug output to see what keys we're getting
-			if (process.env.DEBUG === '1') {
-				console.error(`DEBUG - Processing option: ${key} = ${value}`);
-			}
-
-			// Special case for numTasks > num-tasks (a known problem case)
-			if (key === 'numTasks') {
-				if (process.env.DEBUG === '1') {
-					console.error('DEBUG - Converting numTasks to num-tasks');
-				}
-				if (!userOptions.has('num-tasks') && !userOptions.has('numTasks')) {
-					args.push(`--num-tasks=${value}`);
-				}
-				return;
-			}
-
-			// Skip built-in Commander properties and options the user provided
-			if (
-				['parent', 'commands', 'options', 'rawArgs'].includes(key) ||
-				userOptions.has(key)
-			) {
-				return;
-			}
-
-			// Also check the kebab-case version of this key
-			const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
-			if (userOptions.has(kebabKey)) {
-				return;
-			}
-
-			// Add default values, using kebab-case for the parameter name
-			if (value !== undefined) {
-				if (typeof value === 'boolean') {
-					if (value === true) {
-						args.push(`--${kebabKey}`);
-					} else if (value === false && key === 'generate') {
-						args.push('--skip-generate');
-					}
-				} else {
-					// Always use kebab-case for option names
-					args.push(`--${kebabKey}=${value}`);
-				}
-			}
-		});
-
-		// Special handling for parent parameter (uses -p)
-		if (options.parent && !args.includes('-p') && !userOptions.has('parent')) {
-			args.push('-p', options.parent);
-		}
-
-		// Debug output for troubleshooting
-		if (process.env.DEBUG === '1') {
-			console.error('DEBUG - Command args:', commandArgs);
-			console.error('DEBUG - User options:', Array.from(userOptions));
-			console.error('DEBUG - Commander options:', options);
-			console.error('DEBUG - Final args:', args);
-		}
-
-		// Run the script with our processed args
-		runDevScript(args);
-	};
-}
-
-// // Special case for the 'init' command which uses a different script
-// function registerInitCommand(program) {
-// 	program
-// 		.command('init')
-// 		.description('Initialize a new project')
-// 		.option('-y, --yes', 'Skip prompts and use default values')
-// 		.option('-n, --name <name>', 'Project name')
-// 		.option('-d, --description <description>', 'Project description')
-// 		.option('-v, --version <version>', 'Project version')
-// 		.option('-a, --author <author>', 'Author name')
-// 		.option('--skip-install', 'Skip installing dependencies')
-// 		.option('--dry-run', 'Show what would be done without making changes')
-// 		.action((options) => {
-// 			// Pass through any options to the init script
-// 			const args = [
-// 				'--yes',
-// 				'name',
-// 				'description',
-// 				'version',
-// 				'author',
-// 				'skip-install',
-// 				'dry-run'
-// 			]
-// 				.filter((opt) => options[opt])
-// 				.map((opt) => {
-// 					if (opt === 'yes' || opt === 'skip-install' || opt === 'dry-run') {
-// 						return `--${opt}`;
-// 					}
-// 					return `--${opt}=${options[opt]}`;
-// 				});
-
-// 			const child = spawn('node', [initScriptPath, ...args], {
-// 				stdio: 'inherit',
-// 				cwd: process.cwd()
-// 			});
-
-// 			child.on('close', (code) => {
-// 				process.exit(code);
-// 			});
-// 		});
-// }
-
-// Set up the command-line interface
-const program = new Command();
-
-program
-	.name('task-master')
-	.description('Claude Task Master CLI')
-	.version(version)
-	.addHelpText('afterAll', () => {
-		// Use the same help display function as dev.js for consistency
-		displayHelp();
-		return ''; // Return empty string to prevent commander's default help
-	});
-
-// Add custom help option to directly call our help display
-program.helpOption('-h, --help', 'Display help information');
-program.on('--help', () => {
-	displayHelp();
-});
-
-// // Add special case commands
-// registerInitCommand(program);
-
-program
-	.command('dev')
-	.description('Run the dev.js script')
-	.action(() => {
-		const args = process.argv.slice(process.argv.indexOf('dev') + 1);
-		runDevScript(args);
-	});
-
-// Use a temporary Command instance to get all command definitions
-const tempProgram = new Command();
-registerCommands(tempProgram);
-
-// For each command in the temp instance, add a modified version to our actual program
-tempProgram.commands.forEach((cmd) => {
-	if (['dev'].includes(cmd.name())) {
-		// Skip commands we've already defined specially
-		return;
-	}
-
-	// Create a new command with the same name and description
-	const newCmd = program.command(cmd.name()).description(cmd.description());
-
-	// Copy all options
-	cmd.options.forEach((opt) => {
-		newCmd.option(opt.flags, opt.description, opt.defaultValue);
-	});
-
-	// Set the action to proxy to dev.js
-	newCmd.action(createDevScriptAction(cmd.name()));
-});
-
-// Parse the command line arguments
-program.parse(process.argv);
-
-// Add global error handling for unknown commands and options
-process.on('uncaughtException', (err) => {
-	// Check if this is a commander.js unknown option error
-	if (err.code === 'commander.unknownOption') {
-		const option = err.message.match(/'([^']+)'/)?.[1];
-		const commandArg = process.argv.find(
-			(arg) =>
-				!arg.startsWith('-') &&
-				arg !== 'task-master' &&
-				!arg.includes('/') &&
-				arg !== 'node'
-		);
-		const command = commandArg || 'unknown';
-
-		console.error(chalk.red(`Error: Unknown option '${option}'`));
-		console.error(
-			chalk.yellow(
-				`Run 'task-master ${command} --help' to see available options for this command`
-			)
-		);
-		process.exit(1);
-	}
-
-	// Check if this is a commander.js unknown command error
-	if (err.code === 'commander.unknownCommand') {
-		const command = err.message.match(/'([^']+)'/)?.[1];
-
-		console.error(chalk.red(`Error: Unknown command '${command}'`));
-		console.error(
-			chalk.yellow(`Run 'task-master --help' to see available commands`)
-		);
-		process.exit(1);
-	}
-
-	// Handle other uncaught exceptions
-	console.error(chalk.red(`Error: ${err.message}`));
-	if (process.env.DEBUG === '1') {
-		console.error(err);
-	}
-	process.exit(1);
-});
-
-// Show help if no command was provided (just 'task-master' with no args)
-if (process.argv.length <= 2) {
-	displayBanner();
-	displayHelp();
-	process.exit(0);
-}
-
-// Add exports at the end of the file
-export { detectCamelCaseFlags };
+// Simply run the CLI directly
+runCLI();

docs/CLI-COMMANDER-PATTERN.md

@@ -0,0 +1,131 @@
+# CLI Commander Class Pattern
+
+## Overview
+We're using Commander.js's native class pattern instead of custom abstractions. This is cleaner, more maintainable, and uses the framework as designed.
+
+## Architecture
+
+```
+@tm/core (Business Logic)          @tm/cli (Presentation)
+┌─────────────────────┐            ┌──────────────────────────┐
+│ TaskMasterCore      │◄───────────│ ListTasksCommand         │
+│ - getTaskList()     │            │ extends Commander.Command│
+│ - getTask()         │            │ - display logic only     │
+│ - getNextTask()     │            │ - formatting             │
+└─────────────────────┘            └──────────────────────────┘
+         ▲                                      ▲
+         │                                      │
+         └──────── Gets Data ──────────────────┘
+                                     Displays Data
+```
+
+## Implementation
+
+### Command Class Pattern
+
+```typescript
+// apps/cli/src/commands/list-tasks-commander.ts
+export class ListTasksCommand extends Command {
+  constructor(name?: string) {
+    super(name || 'list');
+    
+    this
+      .description('List tasks')
+      .option('-s, --status <status>', 'Filter by status')
+      .action(async (options) => {
+        // 1. Get data from @tm/core
+        const result = await this.tmCore.getTaskList(options);
+        
+        // 2. Display data (presentation only)
+        this.displayResults(result, options);
+      });
+  }
+}
+```
+
+### Main CLI Class
+
+```typescript
+// apps/cli/src/cli-commander.ts
+class TaskMasterCLI extends Command {
+  createCommand(name?: string): Command {
+    switch (name) {
+      case 'list':
+        return new ListTasksCommand(name);
+      default:
+        return new Command(name);
+    }
+  }
+}
+```
+
+## Integration with Existing Scripts
+
+### Gradual Migration Path
+
+```javascript
+// scripts/modules/commands.js
+
+// OLD WAY (keep working during migration)
+program
+  .command('old-list')
+  .action(async (options) => {
+    await listTasksV2(...);
+  });
+
+// NEW WAY (add alongside old)
+import { ListTasksCommand } from '@tm/cli';
+program.addCommand(new ListTasksCommand());
+```
+
+### Benefits
+
+1. **No Custom Abstractions**: Using Commander.js as designed
+2. **Clean Separation**: Business logic in core, presentation in CLI
+3. **Gradual Migration**: Can migrate one command at a time
+4. **Type Safety**: Full TypeScript support with Commander types
+5. **Framework Native**: Better documentation, examples, and community support
+
+## Migration Steps
+
+1. **Phase 1**: Build command classes in @tm/cli (current)
+2. **Phase 2**: Import in scripts/modules/commands.js
+3. **Phase 3**: Replace old implementations one by one
+4. **Phase 4**: Remove old code when all migrated
+
+## Example Usage
+
+### In New Code
+```javascript
+import { ListTasksCommand } from '@tm/cli';
+const program = new Command();
+program.addCommand(new ListTasksCommand());
+```
+
+### In Existing Scripts
+```javascript
+// Gradual adoption
+const listCmd = new ListTasksCommand();
+program.addCommand(listCmd);
+```
+
+### Programmatic Usage
+```javascript
+const listCommand = new ListTasksCommand();
+await listCommand.parseAsync(['node', 'script', '--format', 'json']);
+```
+
+## POC Status
+
+✅ **Completed**:
+- ListTasksCommand extends Commander.Command
+- Clean separation of concerns
+- Integration examples
+- Build configuration
+
+🚧 **Next Steps**:
+- Migrate more commands
+- Update existing scripts to use new classes
+- Remove old implementations gradually
+
+This POC proves the pattern works and provides a clean migration path!

docs/cross-tag-task-movement.md

@@ -65,11 +65,10 @@ This removes the dependency relationships and moves only the specified task.
 
 ### Force Move
 
-Force the move even with dependency conflicts:
+Note: Force moves are no longer supported. Instead, use one of these options:
 
-```bash
-task-master move --from=5 --from-tag=backlog --to-tag=in-progress --force
-```
+- `--with-dependencies` — move dependents together
+- `--ignore-dependencies` — break cross-tag dependencies
 
 ⚠️ **Warning**: This may break dependency relationships and should be used with caution.
 
@@ -93,7 +92,7 @@ Resolution options:
   2. Break dependencies: task-master move --from=5,6 --from-tag=backlog --to-tag=in-progress --ignore-dependencies
   3. Validate and fix dependencies: task-master validate-dependencies && task-master fix-dependencies
   4. Move dependencies first: task-master move --from=2,3 --from-tag=backlog --to-tag=in-progress
-  5. Force move (may break dependencies): task-master move --from=5,6 --from-tag=backlog --to-tag=in-progress --force
+  5. After deciding, re-run the move with either --with-dependencies or --ignore-dependencies
 ```
 
 ### Subtask Movement Restrictions
@@ -149,7 +148,6 @@ task-master fix-dependencies
 
 - **`--with-dependencies`**: When you want to maintain task relationships
 - **`--ignore-dependencies`**: When you want to break cross-tag dependencies
-- **`--force`**: Only when you understand the consequences
 
 ### 3. Organize by Context
 
@@ -265,9 +263,14 @@ task-master move --from=5 --from-tag=backlog --to-tag=done --ignore-dependencies
 
 ### Scenario 3: Force Move
 
+Choose one of these options explicitly:
+
 ```bash
-# Force move despite conflicts
-task-master move --from=5 --from-tag=backlog --to-tag=in-progress --force
+# Move together with dependencies
+task-master move --from=5 --from-tag=backlog --to-tag=in-progress --with-dependencies
+
+# Or break dependencies
+task-master move --from=5 --from-tag=backlog --to-tag=in-progress --ignore-dependencies
 ```
 
 ### Scenario 4: Moving Subtasks

docs/mcp-provider-guide.md

@@ -451,8 +451,8 @@ When using Task Master in VS Code with MCP support:
 {
   "servers": {
     "task-master-dev": {
-      "command": "node",
-      "args": ["mcp-server/server.js"],
+      "command": "npx",
+      "args": ["-y", "task-master-ai"],
       "cwd": "/path/to/your/task-master-project",
       "env": {
         "NODE_ENV": "development",

docs/models.md

@@ -1,4 +1,4 @@
-# Available Models as of August 12, 2025
+# Available Models as of September 19, 2025
 
 ## Main Models
 
@@ -13,6 +13,10 @@
 | mcp         | mcp-sampling                                   | —         | 0          | 0           |
 | gemini-cli  | gemini-2.5-pro                                 | 0.72      | 0          | 0           |
 | gemini-cli  | gemini-2.5-flash                               | 0.71      | 0          | 0           |
+| grok-cli    | grok-4-latest                                  | 0.7       | 0          | 0           |
+| grok-cli    | grok-3-latest                                  | 0.65      | 0          | 0           |
+| grok-cli    | grok-3-fast                                    | 0.6       | 0          | 0           |
+| grok-cli    | grok-3-mini-fast                               | 0.55      | 0          | 0           |
 | openai      | gpt-4o                                         | 0.332     | 2.5        | 10          |
 | openai      | o1                                             | 0.489     | 15         | 60          |
 | openai      | o3                                             | 0.5       | 2          | 8           |
@@ -99,6 +103,10 @@
 | mcp         | mcp-sampling                                 | —         | 0          | 0           |
 | gemini-cli  | gemini-2.5-pro                               | 0.72      | 0          | 0           |
 | gemini-cli  | gemini-2.5-flash                             | 0.71      | 0          | 0           |
+| grok-cli    | grok-4-latest                                | 0.7       | 0          | 0           |
+| grok-cli    | grok-3-latest                                | 0.65      | 0          | 0           |
+| grok-cli    | grok-3-fast                                  | 0.6       | 0          | 0           |
+| grok-cli    | grok-3-mini-fast                             | 0.55      | 0          | 0           |
 | openai      | gpt-4o-search-preview                        | 0.33      | 2.5        | 10          |
 | openai      | gpt-4o-mini-search-preview                   | 0.3       | 0.15       | 0.6         |
 | xai         | grok-3                                       | —         | 3          | 15          |
@@ -135,6 +143,10 @@
 | mcp         | mcp-sampling                                   | —         | 0          | 0           |
 | gemini-cli  | gemini-2.5-pro                                 | 0.72      | 0          | 0           |
 | gemini-cli  | gemini-2.5-flash                               | 0.71      | 0          | 0           |
+| grok-cli    | grok-4-latest                                  | 0.7       | 0          | 0           |
+| grok-cli    | grok-3-latest                                  | 0.65      | 0          | 0           |
+| grok-cli    | grok-3-fast                                    | 0.6       | 0          | 0           |
+| grok-cli    | grok-3-mini-fast                               | 0.55      | 0          | 0           |
 | openai      | gpt-4o                                         | 0.332     | 2.5        | 10          |
 | openai      | o3                                             | 0.5       | 2          | 8           |
 | openai      | o4-mini                                        | 0.45      | 1.1        | 4.4         |

docs/tutorial.md

@@ -23,7 +23,7 @@ npm i -g task-master-ai
   "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",
@@ -145,7 +145,7 @@ You can also set up the MCP server in Cursor settings:
 4. Configure with the following details:
    - Name: "Task Master"
    - Type: "Command"
-   - Command: "npx -y --package=task-master-ai task-master-ai"
+   - Command: "npx -y task-master-ai"
 5. Save the settings
 
 Once configured, you can interact with Task Master's task management commands directly through Cursor's interface, providing a more integrated experience.

jest.config.js

@@ -18,7 +18,17 @@ export default {
 	testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js'],
 
 	// Transform files
-	transform: {},
+	preset: 'ts-jest/presets/default-esm',
+	extensionsToTreatAsEsm: ['.ts'],
+	moduleFileExtensions: ['js', 'ts', 'json', 'node'],
+	transform: {
+		'^.+\\.ts$': [
+			'ts-jest',
+			{
+				useESM: true
+			}
+		]
+	},
 
 	// Disable transformations for node_modules
 	transformIgnorePatterns: ['/node_modules/'],
@@ -27,6 +37,7 @@ export default {
 	moduleNameMapper: {
 		'^@/(.*)$': '<rootDir>/$1'
 	},
+	resolver: '<rootDir>/jest.resolver.cjs',
 
 	// Setup module aliases
 	moduleDirectories: ['node_modules', '<rootDir>'],

jest.resolver.cjs

@@ -0,0 +1,19 @@
+const { defaultResolver } = require('jest-resolve');
+module.exports = function customResolver(request, options) {
+	const resolve = options.defaultResolver || defaultResolver;
+
+	try {
+		return resolve(request, options);
+	} catch (error) {
+		if (request.startsWith('.') && request.endsWith('.js')) {
+			try {
+				return resolve(request.replace(/\.js$/, '.ts'), options);
+			} catch (tsError) {
+				tsError.cause = tsError.cause ?? error;
+				throw tsError;
+			}
+		}
+
+		throw error;
+	}
+};

llms-install.md

@@ -17,7 +17,7 @@ Add the following configuration to the user's MCP settings file (`.cursor/mcp.js
 	"mcpServers": {
 		"taskmaster-ai": {
 			"command": "npx",
-			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
+			"args": ["-y", "task-master-ai"],
 			"env": {
 				"ANTHROPIC_API_KEY": "user_will_add_their_key_here",
 				"PERPLEXITY_API_KEY": "user_will_add_their_key_here",

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

@@ -189,6 +189,17 @@ export async function moveTaskCrossTagDirect(args, log, context = {}) {
 				'Verify task IDs exist: task-master list',
 				'Check task details: task-master show <id>'
 			];
+		} else if (
+			error.code === 'TASK_ALREADY_EXISTS' ||
+			error.message?.includes('already exists in target tag')
+		) {
+			// Target tag has an ID collision
+			errorCode = 'TASK_ALREADY_EXISTS';
+			suggestions = [
+				'Choose a different target tag without conflicting IDs',
+				'Move a different set of IDs (avoid existing ones)',
+				'If needed, move within-tag to a new ID first, then cross-tag move'
+			];
 		}
 
 		return {

mcp-server/src/index.js

@@ -7,6 +7,7 @@ import logger from './logger.js';
 import { registerTaskMasterTools } from './tools/index.js';
 import ProviderRegistry from '../../src/provider-registry/index.js';
 import { MCPProvider } from './providers/mcp-provider.js';
+import packageJson from '../../package.json' with { type: 'json' };
 
 // Load environment variables
 dotenv.config();
@@ -20,10 +21,6 @@ const __dirname = path.dirname(__filename);
  */
 class TaskMasterMCPServer {
 	constructor() {
-		// Get version from package.json using synchronous fs
-		const packagePath = path.join(__dirname, '../../package.json');
-		const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-
 		this.options = {
 			name: 'Task Master MCP Server',
 			version: packageJson.version

mcp-server/src/tools/utils.js

@@ -8,6 +8,7 @@ import path from 'path';
 import fs from 'fs';
 import { contextManager } from '../core/context-manager.js'; // Import the singleton
 import { fileURLToPath } from 'url';
+import packageJson from '../../../package.json' with { type: 'json' };
 import { getCurrentTag } from '../../../scripts/modules/utils.js';
 
 // Import path utilities to ensure consistent path resolution
@@ -31,33 +32,12 @@ function getVersionInfo() {
 		return cachedVersionInfo;
 	}
 
-	try {
-		// Navigate to the project root from the tools directory
-		const packageJsonPath = path.join(
-			path.dirname(__filename),
-			'../../../package.json'
-		);
-		if (fs.existsSync(packageJsonPath)) {
-			const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-			cachedVersionInfo = {
-				version: packageJson.version,
-				name: packageJson.name
-			};
-			return cachedVersionInfo;
-		}
-		cachedVersionInfo = {
-			version: 'unknown',
-			name: 'task-master-ai'
-		};
-		return cachedVersionInfo;
-	} catch (error) {
-		// Fallback version info if package.json can't be read
-		cachedVersionInfo = {
-			version: 'unknown',
-			name: 'task-master-ai'
-		};
-		return cachedVersionInfo;
-	}
+	// Use the imported packageJson directly
+	cachedVersionInfo = {
+		version: packageJson.version || 'unknown',
+		name: packageJson.name || 'task-master-ai'
+	};
+	return cachedVersionInfo;
 }
 
 /**

package.json

@@ -1,29 +1,41 @@
 {
 	"name": "task-master-ai",
-	"version": "0.24.0",
+	"version": "0.27.2",
 	"description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
 	"main": "index.js",
 	"type": "module",
 	"bin": {
-		"task-master": "bin/task-master.js",
-		"task-master-mcp": "mcp-server/server.js",
-		"task-master-ai": "mcp-server/server.js"
+		"task-master": "dist/task-master.js",
+		"task-master-mcp": "dist/mcp-server.js",
+		"task-master-ai": "dist/mcp-server.js"
 	},
-	"workspaces": ["apps/*", "."],
+	"workspaces": ["apps/*", "packages/*", "."],
 	"scripts": {
+		"build": "npm run build:build-config && cross-env NODE_ENV=production tsdown",
+		"dev": "tsdown --watch",
+		"turbo:dev": "turbo dev",
+		"turbo:build": "turbo build",
+		"turbo:typecheck": "turbo typecheck",
+		"build:build-config": "npm run build -w @tm/build-config",
 		"test": "node --experimental-vm-modules node_modules/.bin/jest",
+		"test:unit": "node --experimental-vm-modules node_modules/.bin/jest --testPathPattern=unit",
+		"test:integration": "node --experimental-vm-modules node_modules/.bin/jest --testPathPattern=integration",
 		"test:fails": "node --experimental-vm-modules node_modules/.bin/jest --onlyFailures",
 		"test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
 		"test:coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
+		"test:ci": "node --experimental-vm-modules node_modules/.bin/jest --coverage --ci",
 		"test:e2e": "./tests/e2e/run_e2e.sh",
 		"test:e2e-report": "./tests/e2e/run_e2e.sh --analyze-log",
-		"prepare": "chmod +x bin/task-master.js mcp-server/server.js",
+		"postpack": "chmod +x dist/task-master.js dist/mcp-server.js",
 		"changeset": "changeset",
 		"release": "changeset publish",
-		"inspector": "npx @modelcontextprotocol/inspector node mcp-server/server.js",
-		"mcp-server": "node mcp-server/server.js",
+		"publish-packages": "turbo run build lint test && changeset version && changeset publish",
+		"inspector": "npx @modelcontextprotocol/inspector node dist/mcp-server.js",
+		"mcp-server": "node dist/mcp-server.js",
 		"format-check": "biome format .",
-		"format": "biome format . --write"
+		"format": "biome format . --write",
+		"deps:check": "manypkg check || echo 'Note: Workspace package version warnings are expected for internal @tm/* packages'",
+		"deps:fix": "manypkg fix"
 	},
 	"keywords": [
 		"claude",
@@ -55,15 +67,16 @@
 		"@inquirer/search": "^3.0.15",
 		"@openrouter/ai-sdk-provider": "^0.4.5",
 		"@streamparser/json": "^0.0.22",
+		"@supabase/supabase-js": "^2.57.4",
 		"ai": "^4.3.10",
 		"ajv": "^8.17.1",
 		"ajv-formats": "^3.0.1",
 		"boxen": "^8.0.1",
-		"chalk": "^5.4.1",
+		"chalk": "5.6.2",
 		"cli-highlight": "^2.1.11",
 		"cli-progress": "^3.12.0",
 		"cli-table3": "^0.6.5",
-		"commander": "^11.1.0",
+		"commander": "^12.1.0",
 		"cors": "^2.8.5",
 		"dotenv": "^16.3.1",
 		"express": "^4.21.2",
@@ -78,6 +91,8 @@
 		"jsonrepair": "^3.13.0",
 		"jsonwebtoken": "^9.0.2",
 		"lru-cache": "^10.2.0",
+		"marked": "^15.0.12",
+		"marked-terminal": "^7.3.0",
 		"ollama-ai-provider": "^1.2.0",
 		"openai": "^4.89.0",
 		"ora": "^8.2.0",
@@ -86,13 +101,14 @@
 		"zod-to-json-schema": "^3.24.5"
 	},
 	"optionalDependencies": {
-		"@anthropic-ai/claude-code": "^1.0.25",
+		"@anthropic-ai/claude-code": "^1.0.88",
 		"@biomejs/cli-linux-x64": "^1.9.4",
-		"ai-sdk-provider-gemini-cli": "^0.1.1"
+		"ai-sdk-provider-gemini-cli": "^0.1.3"
 	},
 	"engines": {
 		"node": ">=18.0.0"
 	},
+	"packageManager": "npm@10.9.2",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/eyaltoledano/claude-task-master.git"
@@ -101,16 +117,7 @@
 	"bugs": {
 		"url": "https://github.com/eyaltoledano/claude-task-master/issues"
 	},
-	"files": [
-		"scripts/**",
-		"assets/**",
-		".cursor/**",
-		"README-task-master.md",
-		"index.js",
-		"bin/**",
-		"mcp-server/**",
-		"src/**"
-	],
+	"files": ["dist/**", "README-task-master.md", "README.md", "LICENSE"],
 	"overrides": {
 		"node-fetch": "^2.6.12",
 		"whatwg-url": "^11.0.0"
@@ -119,14 +126,23 @@
 		"@biomejs/biome": "^1.9.4",
 		"@changesets/changelog-github": "^0.5.1",
 		"@changesets/cli": "^2.28.1",
+		"@manypkg/cli": "^0.25.1",
+		"@tm/cli": "*",
 		"@types/jest": "^29.5.14",
+		"@types/marked-terminal": "^6.1.1",
+		"concurrently": "^9.2.1",
+		"cross-env": "^10.0.0",
+		"dotenv-mono": "^1.5.1",
 		"execa": "^8.0.1",
-		"ink": "^5.0.1",
 		"jest": "^29.7.0",
 		"jest-environment-node": "^29.7.0",
 		"mock-fs": "^5.5.0",
 		"prettier": "^3.5.3",
 		"supertest": "^7.1.0",
-		"tsx": "^4.16.2"
+		"ts-jest": "^29.4.2",
+		"tsdown": "^0.15.2",
+		"tsx": "^4.20.4",
+		"turbo": "^2.5.6",
+		"typescript": "^5.7.3"
 	}
 }

packages/build-config/CHANGELOG.md

@@ -0,0 +1,5 @@
+# @tm/build-config
+
+## null
+
+## 1.0.1

packages/build-config/package.json

@@ -0,0 +1,29 @@
+{
+	"name": "@tm/build-config",
+	"description": "Shared build configuration for Task Master monorepo",
+	"type": "module",
+	"private": true,
+	"main": "./dist/tsdown.base.js",
+	"types": "./src/tsdown.base.ts",
+	"exports": {
+		".": {
+			"types": "./src/tsdown.base.ts",
+			"import": "./dist/tsdown.base.js"
+		}
+	},
+	"files": ["dist", "src"],
+	"keywords": ["build-config", "tsup", "monorepo"],
+	"author": "",
+	"license": "MIT",
+	"scripts": {
+		"build": "tsc",
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"dotenv-mono": "^1.5.1",
+		"typescript": "^5.7.3"
+	},
+	"dependencies": {
+		"tsup": "^8.5.0"
+	}
+}

packages/build-config/src/tsdown.base.ts

@@ -0,0 +1,51 @@
+/**
+ * Base tsdown configuration for Task Master monorepo
+ * Provides shared configuration that can be extended by individual packages
+ */
+import type { UserConfig } from 'tsdown';
+
+const isProduction = process.env.NODE_ENV === 'production';
+const isDevelopment = !isProduction;
+
+/**
+ * Environment helpers
+ */
+export const env = {
+	isProduction,
+	isDevelopment,
+	NODE_ENV: process.env.NODE_ENV || 'development'
+};
+
+/**
+ * Base tsdown configuration for all packages
+ * Since everything gets bundled into root dist/ anyway, use consistent settings
+ */
+export const baseConfig: Partial<UserConfig> = {
+	sourcemap: isDevelopment,
+	format: 'esm',
+	platform: 'node',
+	dts: isDevelopment,
+	minify: isProduction,
+	treeshake: isProduction,
+	// Better debugging in development
+	...(isDevelopment && {
+		keepNames: true,
+		splitting: false // Disable code splitting for better stack traces
+	}),
+	// Keep all npm dependencies external (available via node_modules)
+	external: [/^[^@./]/, /^@(?!tm\/)/]
+};
+
+/**
+ * Utility function to merge configurations
+ * Simplified for tsdown usage
+ */
+export function mergeConfig(
+	base: Partial<UserConfig>,
+	overrides: Partial<UserConfig>
+): Partial<UserConfig> {
+	return {
+		...base,
+		...overrides
+	};
+}

packages/build-config/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"lib": ["ES2022"],
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"allowSyntheticDefaultImports": true,
+		"esModuleInterop": true,
+		"baseUrl": ".",
+		"outDir": "dist",
+		"allowJs": true,
+		"strict": true,
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"declaration": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}

packages/tm-core/.gitignore

@@ -0,0 +1,83 @@
+# Dependencies
+node_modules/
+*.pnp
+.pnp.js
+
+# Build output
+dist/
+build/
+*.tsbuildinfo
+
+# Coverage reports
+coverage/
+*.lcov
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# nyc test coverage
+.nyc_output
+
+# Dependency directories
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db

packages/tm-core/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+## null
+
+## 0.26.1
+
+All notable changes to the @task-master/tm-core package will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Initial package structure and configuration
+- TypeScript support with strict mode
+- Dual ESM/CJS build system with tsup
+- Jest testing framework with TypeScript support
+- ESLint and Prettier for code quality
+- Modular architecture with barrel exports
+- Placeholder implementations for all modules
+- Comprehensive documentation and README
+
+### Development Infrastructure
+
+- tsup configuration for dual format builds
+- Jest configuration with ESM support
+- ESLint configuration with TypeScript rules
+- Prettier configuration for consistent formatting
+- Complete package.json with all required fields
+- TypeScript configuration with strict settings
+- .gitignore for development files
+
+### Package Structure
+
+- `src/types/` - TypeScript type definitions (placeholder)
+- `src/providers/` - AI provider implementations (placeholder)
+- `src/storage/` - Storage layer abstractions (placeholder)
+- `src/parser/` - Task parsing utilities (placeholder)
+- `src/utils/` - Common utility functions (placeholder)
+- `src/errors/` - Custom error classes (placeholder)
+- `tests/` - Test directories and setup
+
+## [1.0.0] - TBD
+
+### Planned Features
+
+- Complete TypeScript type system
+- AI provider implementations
+- Storage adapters
+- Task parsing capabilities
+- Comprehensive utility functions
+- Custom error handling
+- Full test coverage
+- Complete documentation
+
+---
+
+## Release Notes
+
+### Version 1.0.0 (Coming Soon)
+
+This will be the first stable release of tm-core with complete implementations of all modules. Currently, all modules contain placeholder implementations to establish the package structure and enable development of dependent packages.
+
+### Development Status
+
+- ✅ Package structure and configuration
+- ✅ Build and test infrastructure
+- ✅ Development tooling setup
+- 🚧 TypeScript types implementation (Task 116)
+- 🚧 AI provider system (Task 117)
+- 🚧 Storage layer (Task 118)
+- 🚧 Task parser (Task 119)
+- 🚧 Utility functions (Task 120)
+- 🚧 Error handling (Task 121)
+- 🚧 Configuration system (Task 122)
+- 🚧 Testing infrastructure (Task 123)
+- 🚧 Documentation (Task 124)
+- 🚧 Package finalization (Task 125)