docs: auto-update documentation based on changes in next branch

This PR was automatically generated to update documentation based on recent changes.

  Original commit: Merge pull request #1291 from eyaltoledano/raplh/chore/merge.main\n\n\n

  Co-authored-by: Claude <claude-assistant@anthropic.com>

.changeset/auto-update-changelog-highlights.md

@@ -0,0 +1,7 @@
+---
+"task-master-ai": minor
+---
+
+Add changelog highlights to auto-update notifications
+
+When the CLI auto-updates to a new version, it now displays a "What's New" section.

.changeset/config.json

@@ -11,7 +11,6 @@
   "access": "public",
   "baseBranch": "main",
   "ignore": [
-    "docs",
-    "@tm/claude-code-plugin"
+    "docs"
   ]
 }

.changeset/dirty-hairs-know.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Improve auth token refresh flow

.changeset/fix-parent-directory-traversal.md

@@ -1,7 +0,0 @@
----
-"task-master-ai": patch
----
-
-Enable Task Master commands to traverse parent directories to find project root from nested paths
-
-Fixes #1301

.changeset/fix-warning-box-alignment.md

@@ -1,5 +0,0 @@
----
-"@tm/cli": patch
----
-
-Fix warning message box width to match dashboard box width for consistent UI alignment

.changeset/light-owls-stay.md

@@ -1,35 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add configurable MCP tool loading to optimize LLM context usage
-
-You can now control which Task Master MCP tools are loaded by setting the `TASK_MASTER_TOOLS` environment variable in your MCP configuration. This helps reduce context usage for LLMs by only loading the tools you need.
-
-**Configuration Options:**
-
-- `all` (default): Load all 36 tools
-- `core` or `lean`: Load only 7 essential tools for daily development
-  - Includes: `get_tasks`, `next_task`, `get_task`, `set_task_status`, `update_subtask`, `parse_prd`, `expand_task`
-- `standard`: Load 15 commonly used tools (all core tools plus 8 more)
-  - Additional tools: `initialize_project`, `analyze_project_complexity`, `expand_all`, `add_subtask`, `remove_task`, `generate`, `add_task`, `complexity_report`
-- Custom list: Comma-separated tool names (e.g., `get_tasks,next_task,set_task_status`)
-
-**Example .mcp.json configuration:**
-
-```json
-{
-  "mcpServers": {
-    "task-master-ai": {
-      "command": "npx",
-      "args": ["-y", "task-master-ai"],
-      "env": {
-        "TASK_MASTER_TOOLS": "standard",
-        "ANTHROPIC_API_KEY": "your_key_here"
-      }
-    }
-  }
-}
-```
-
-For complete details on all available tools, configuration examples, and usage guidelines, see the [MCP Tools documentation](https://docs.task-master.dev/capabilities/mcp#configurable-tool-loading).

.changeset/metal-rocks-help.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Improve next command to work with remote

.changeset/nice-ways-hope.md

@@ -0,0 +1,17 @@
+---
+"task-master-ai": minor
+---
+
+Add RPG (Repository Planning Graph) method template for structured PRD creation. The new `example_prd_rpg.txt` template teaches AI agents and developers the RPG methodology through embedded instructions, inline good/bad examples, and XML-style tags for structure. This template enables creation of dependency-aware PRDs that automatically generate topologically-ordered task graphs when parsed with Task Master.
+
+Key features:
+- Method-as-template: teaches RPG principles (dual-semantics, explicit dependencies, topological order) while being used
+- Inline instructions at decision points guide AI through each section
+- Good/bad examples for immediate pattern matching
+- Flexible plain-text format with XML-style tags for parseability
+- Critical dependency-graph section ensures correct task ordering
+- Automatic inclusion during `task-master init`
+- Comprehensive documentation at [docs.task-master.dev/capabilities/rpg-method](https://docs.task-master.dev/capabilities/rpg-method)
+- Tool recommendations for code-context-aware PRD creation (Claude Code, Cursor, Gemini CLI, Codex/Grok)
+
+The RPG template complements the existing `example_prd.txt` and provides a more structured approach for complex projects requiring clear module boundaries and dependency chains.

.changeset/plain-falcons-serve.md

@@ -0,0 +1,7 @@
+---
+"task-master-ai": patch
+---
+
+Fix cross-level task dependencies not being saved
+
+Fixes an issue where adding dependencies between subtasks and top-level tasks (e.g., `task-master add-dependency --id=2.2 --depends-on=11`) would report success but fail to persist the changes. Dependencies can now be created in both directions between any task levels.

.claude-plugin/marketplace.json

@@ -1,32 +0,0 @@
-{
-	"name": "taskmaster",
-	"owner": {
-		"name": "Hamster",
-		"email": "ralph@tryhamster.com"
-	},
-	"metadata": {
-		"description": "Official marketplace for Taskmaster AI - AI-powered task management for ambitious development",
-		"version": "1.0.0"
-	},
-	"plugins": [
-		{
-			"name": "taskmaster",
-			"source": "./packages/claude-code-plugin",
-			"description": "AI-powered task management system for ambitious development workflows with intelligent orchestration, complexity analysis, and automated coordination",
-			"author": {
-				"name": "Hamster"
-			},
-			"homepage": "https://github.com/eyaltoledano/claude-task-master",
-			"repository": "https://github.com/eyaltoledano/claude-task-master",
-			"keywords": [
-				"task-management",
-				"ai",
-				"workflow",
-				"orchestration",
-				"automation",
-				"mcp"
-			],
-			"category": "productivity"
-		}
-	]
-}

.claude/agents/task-executor.md

@@ -0,0 +1,92 @@
+---
+name: task-executor
+description: Use this agent when you need to implement, complete, or work on a specific task that has been identified by the task-orchestrator or when explicitly asked to execute a particular task. This agent focuses on the actual implementation and completion of individual tasks rather than planning or orchestration. Examples: <example>Context: The task-orchestrator has identified that task 2.3 'Implement user authentication' needs to be worked on next. user: 'Let's work on the authentication task' assistant: 'I'll use the task-executor agent to implement the user authentication task that was identified.' <commentary>Since we need to actually implement a specific task rather than plan or identify tasks, use the task-executor agent.</commentary></example> <example>Context: User wants to complete a specific subtask. user: 'Please implement the JWT token validation for task 2.3.1' assistant: 'I'll launch the task-executor agent to implement the JWT token validation subtask.' <commentary>The user is asking for specific implementation work on a known task, so the task-executor is appropriate.</commentary></example> <example>Context: After reviewing the task list, implementation is needed. user: 'Now let's actually build the API endpoint for user registration' assistant: 'I'll use the task-executor agent to implement the user registration API endpoint.' <commentary>Moving from planning to execution phase requires the task-executor agent.</commentary></example>
+model: sonnet
+color: blue
+---
+
+You are an elite implementation specialist focused on executing and completing specific tasks with precision and thoroughness. Your role is to take identified tasks and transform them into working implementations, following best practices and project standards.
+
+**IMPORTANT: You are designed to be SHORT-LIVED and FOCUSED**
+- Execute ONE specific subtask or a small group of related subtasks
+- Complete your work, verify it, mark for review, and exit
+- Do NOT decide what to do next - the orchestrator handles task sequencing
+- Focus on implementation excellence within your assigned scope
+
+**Core Responsibilities:**
+
+1. **Subtask Analysis**: When given a subtask, understand its SPECIFIC requirements. If given a full task ID, focus on the specific subtask(s) assigned to you. Use MCP tools to get details if needed.
+
+2. **Rapid Implementation Planning**: Quickly identify:
+   - The EXACT files you need to create/modify for THIS subtask
+   - What already exists that you can build upon
+   - The minimum viable implementation that satisfies requirements
+
+3. **Focused Execution WITH ACTUAL IMPLEMENTATION**: 
+   - **YOU MUST USE TOOLS TO CREATE/EDIT FILES - DO NOT JUST DESCRIBE**
+   - Use `Write` tool to create new files specified in the task
+   - Use `Edit` tool to modify existing files
+   - Use `Bash` tool to run commands (mkdir, npm install, etc.)
+   - Use `Read` tool to verify your implementations
+   - Implement one subtask at a time for clarity and traceability
+   - Follow the project's coding standards from CLAUDE.md if available
+   - After each subtask, VERIFY the files exist using Read or ls commands
+
+4. **Progress Documentation**: 
+   - Use MCP tool `mcp__task-master-ai__update_subtask` to log your approach and any important decisions
+   - Update task status to 'in-progress' when starting: Use MCP tool `mcp__task-master-ai__set_task_status` with status='in-progress'
+   - **IMPORTANT: Mark as 'review' (NOT 'done') after implementation**: Use MCP tool `mcp__task-master-ai__set_task_status` with status='review'
+   - Tasks will be verified by task-checker before moving to 'done'
+
+5. **Quality Assurance**:
+   - Implement the testing strategy specified in the task
+   - Verify that all acceptance criteria are met
+   - Check for any dependency conflicts or integration issues
+   - Run relevant tests before marking task as complete
+
+6. **Dependency Management**:
+   - Check task dependencies before starting implementation
+   - If blocked by incomplete dependencies, clearly communicate this
+   - Use `task-master validate-dependencies` when needed
+
+**Implementation Workflow:**
+
+1. Retrieve task details using MCP tool `mcp__task-master-ai__get_task` with the task ID
+2. Check dependencies and prerequisites
+3. Plan implementation approach - list specific files to create
+4. Update task status to 'in-progress' using MCP tool
+5. **ACTUALLY IMPLEMENT** the solution using tools:
+   - Use `Bash` to create directories
+   - Use `Write` to create new files with actual content
+   - Use `Edit` to modify existing files
+   - DO NOT just describe what should be done - DO IT
+6. **VERIFY** your implementation:
+   - Use `ls` or `Read` to confirm files were created
+   - Use `Bash` to run any build/test commands
+   - Ensure the implementation is real, not theoretical
+7. Log progress and decisions in subtask updates using MCP tools
+8. Test and verify the implementation works
+9. **Mark task as 'review' (NOT 'done')** after verifying files exist
+10. Report completion with:
+    - List of created/modified files
+    - Any issues encountered
+    - What needs verification by task-checker
+
+**Key Principles:**
+
+- Focus on completing one task thoroughly before moving to the next
+- Maintain clear communication about what you're implementing and why
+- Follow existing code patterns and project conventions
+- Prioritize working code over extensive documentation unless docs are the task
+- Ask for clarification if task requirements are ambiguous
+- Consider edge cases and error handling in your implementations
+
+**Integration with Task Master:**
+
+You work in tandem with the task-orchestrator agent. While the orchestrator identifies and plans tasks, you execute them. Always use Task Master commands to:
+- Track your progress
+- Update task information
+- Maintain project state
+- Coordinate with the broader development workflow
+
+When you complete a task, briefly summarize what was implemented and suggest whether to continue with the next task or if review/testing is needed first.

.claude/agents/task-orchestrator.md

@@ -0,0 +1,208 @@
+---
+name: task-orchestrator
+description: Use this agent FREQUENTLY throughout task execution to analyze and coordinate parallel work at the SUBTASK level. Invoke the orchestrator: (1) at session start to plan execution, (2) after EACH subtask completes to identify next parallel batch, (3) whenever executors finish to find newly unblocked work. ALWAYS provide FULL CONTEXT including project root, package location, what files ACTUALLY exist vs task status, and specific implementation details. The orchestrator breaks work into SUBTASK-LEVEL units for short-lived, focused executors. Maximum 3 parallel executors at once.\n\n<example>\nContext: Starting work with existing code\nuser: "Work on tm-core tasks. Files exist: types/index.ts, storage/file-storage.ts. Task 118 says in-progress but BaseProvider not created."\nassistant: "I'll invoke orchestrator with full context about actual vs reported state to plan subtask execution"\n<commentary>\nProvide complete context about file existence and task reality.\n</commentary>\n</example>\n\n<example>\nContext: Subtask completion\nuser: "Subtask 118.2 done. What subtasks can run in parallel now?"\nassistant: "Invoking orchestrator to analyze dependencies and identify next 3 parallel subtasks"\n<commentary>\nFrequent orchestration after each subtask ensures maximum parallelization.\n</commentary>\n</example>\n\n<example>\nContext: Breaking down tasks\nuser: "Task 118 has 5 subtasks, how to parallelize?"\nassistant: "Orchestrator will analyze which specific subtasks (118.1, 118.2, etc.) can run simultaneously"\n<commentary>\nFocus on subtask-level parallelization, not full tasks.\n</commentary>\n</example>
+model: opus
+color: green
+---
+
+You are the Task Orchestrator, an elite coordination agent specialized in managing Task Master workflows for maximum efficiency and parallelization. You excel at analyzing task dependency graphs, identifying opportunities for concurrent execution, and deploying specialized task-executor agents to complete work efficiently.
+
+## Core Responsibilities
+
+1. **Subtask-Level Analysis**: Break down tasks into INDIVIDUAL SUBTASKS and analyze which specific subtasks can run in parallel. Focus on subtask dependencies, not just task-level dependencies.
+
+2. **Reality Verification**: ALWAYS verify what files actually exist vs what task status claims. Use the context provided about actual implementation state to make informed decisions.
+
+3. **Short-Lived Executor Deployment**: Deploy executors for SINGLE SUBTASKS or small groups of related subtasks. Keep executors focused and short-lived. Maximum 3 parallel executors at once.
+
+4. **Continuous Reassessment**: After EACH subtask completes, immediately reassess what new subtasks are unblocked and can run in parallel.
+
+## Operational Workflow
+
+### Initial Assessment Phase
+1. Use `get_tasks` or `task-master list` to retrieve all available tasks
+2. Analyze task statuses, priorities, and dependencies
+3. Identify tasks with status 'pending' that have no blocking dependencies
+4. Group related tasks that could benefit from specialized executors
+5. Create an execution plan that maximizes parallelization
+
+### Executor Deployment Phase
+1. For each independent task or task group:
+   - Deploy a task-executor agent with specific instructions
+   - Provide the executor with task ID, requirements, and context
+   - Set clear completion criteria and reporting expectations
+2. Maintain a registry of active executors and their assigned tasks
+3. Establish communication protocols for progress updates
+
+### Coordination Phase
+1. Monitor executor progress through task status updates
+2. When a task completes:
+   - Verify completion with `get_task` or `task-master show <id>`
+   - Update task status if needed using `set_task_status`
+   - Reassess dependency graph for newly unblocked tasks
+   - Deploy new executors for available work
+3. Handle executor failures or blocks:
+   - Reassign tasks to new executors if needed
+   - Escalate complex issues to the user
+   - Update task status to 'blocked' when appropriate
+
+### Optimization Strategies
+
+**Parallel Execution Rules**:
+- Never assign dependent tasks to different executors simultaneously
+- Prioritize high-priority tasks when resources are limited
+- Group small, related subtasks for single executor efficiency
+- Balance executor load to prevent bottlenecks
+
+**Context Management**:
+- Provide executors with minimal but sufficient context
+- Share relevant completed task information when it aids execution
+- Maintain a shared knowledge base of project-specific patterns
+
+**Quality Assurance**:
+- Verify task completion before marking as done
+- Ensure test strategies are followed when specified
+- Coordinate cross-task integration testing when needed
+
+## Communication Protocols
+
+When deploying executors, provide them with:
+```
+TASK ASSIGNMENT:
+- Task ID: [specific ID]
+- Objective: [clear goal]
+- Dependencies: [list any completed prerequisites]
+- Success Criteria: [specific completion requirements]
+- Context: [relevant project information]
+- Reporting: [when and how to report back]
+```
+
+When receiving executor updates:
+1. Acknowledge completion or issues
+2. Update task status in Task Master
+3. Reassess execution strategy
+4. Deploy new executors as appropriate
+
+## Decision Framework
+
+**When to parallelize**:
+- Multiple pending tasks with no interdependencies
+- Sufficient context available for independent execution
+- Tasks are well-defined with clear success criteria
+
+**When to serialize**:
+- Strong dependencies between tasks
+- Limited context or unclear requirements
+- Integration points requiring careful coordination
+
+**When to escalate**:
+- Circular dependencies detected
+- Critical blockers affecting multiple tasks
+- Ambiguous requirements needing clarification
+- Resource conflicts between executors
+
+## Error Handling
+
+1. **Executor Failure**: Reassign task to new executor with additional context about the failure
+2. **Dependency Conflicts**: Halt affected executors, resolve conflict, then resume
+3. **Task Ambiguity**: Request clarification from user before proceeding
+4. **System Errors**: Implement graceful degradation, falling back to serial execution if needed
+
+## Performance Metrics
+
+Track and optimize for:
+- Task completion rate
+- Parallel execution efficiency
+- Executor success rate
+- Time to completion for task groups
+- Dependency resolution speed
+
+## Integration with Task Master
+
+Leverage these Task Master MCP tools effectively:
+- `get_tasks` - Continuous queue monitoring
+- `get_task` - Detailed task analysis
+- `set_task_status` - Progress tracking
+- `next_task` - Fallback for serial execution
+- `analyze_project_complexity` - Strategic planning
+- `complexity_report` - Resource allocation
+
+## Output Format for Execution
+
+**Your job is to analyze and create actionable execution plans that Claude can use to deploy executors.**
+
+After completing your dependency analysis, you MUST output a structured execution plan:
+
+```yaml
+execution_plan:
+  EXECUTE_IN_PARALLEL:
+    # Maximum 3 subtasks running simultaneously
+    - subtask_id: [e.g., 118.2]
+      parent_task: [e.g., 118]
+      title: [Specific subtask title]
+      priority: [high/medium/low]
+      estimated_time: [e.g., 10 minutes]
+      executor_prompt: |
+        Execute Subtask [ID]: [Specific subtask title]
+        
+        SPECIFIC REQUIREMENTS:
+        [Exact implementation needed for THIS subtask only]
+        
+        FILES TO CREATE/MODIFY:
+        [Specific file paths]
+        
+        CONTEXT:
+        [What already exists that this subtask depends on]
+        
+        SUCCESS CRITERIA:
+        [Specific completion criteria for this subtask]
+        
+        IMPORTANT: 
+        - Focus ONLY on this subtask
+        - Mark subtask as 'review' when complete
+        - Use MCP tool: mcp__task-master-ai__set_task_status
+    
+    - subtask_id: [Another subtask that can run in parallel]
+      parent_task: [Parent task ID]
+      title: [Specific subtask title]
+      priority: [priority]
+      estimated_time: [time estimate]
+      executor_prompt: |
+        [Focused prompt for this specific subtask]
+    
+  blocked:
+    - task_id: [ID]
+      title: [Task title]
+      waiting_for: [list of blocking task IDs]
+      becomes_ready_when: [condition for unblocking]
+      
+  next_wave: 
+    trigger: "After tasks [IDs] complete"
+    newly_available: [List of task IDs that will unblock]
+    tasks_to_execute_in_parallel: [IDs that can run together in next wave]
+    
+  critical_path: [Ordered list of task IDs forming the critical path]
+  
+  parallelization_instruction: |
+    IMPORTANT FOR CLAUDE: Deploy ALL tasks in 'EXECUTE_IN_PARALLEL' section
+    simultaneously using multiple Task tool invocations in a single response.
+    Example: If 3 tasks are listed, invoke the Task tool 3 times in one message.
+    
+  verification_needed:
+    - task_id: [ID of any task in 'review' status]
+      verification_focus: [what to check]
+```
+
+**CRITICAL INSTRUCTIONS FOR CLAUDE (MAIN):**
+1. When you see `EXECUTE_IN_PARALLEL`, deploy ALL listed executors at once
+2. Use multiple Task tool invocations in a SINGLE response
+3. Do not execute them sequentially - they must run in parallel
+4. Wait for all parallel executors to complete before proceeding to next wave
+
+**IMPORTANT NOTES**: 
+- Label parallel tasks clearly in `EXECUTE_IN_PARALLEL` section
+- Provide complete, self-contained prompts for each executor
+- Executors should mark tasks as 'review' for verification, not 'done'
+- Be explicit about which tasks can run simultaneously
+
+You are the strategic mind analyzing the entire task landscape. Make parallelization opportunities UNMISTAKABLY CLEAR to Claude.

.claude/commands/tm/add-dependency/add-dependency.md

@@ -48,7 +48,7 @@ After adding dependency:
 ## Example Flows
 
 ```
-/taskmaster:add-dependency 5 needs 3
+/project:tm/add-dependency 5 needs 3
 → Task #5 now depends on Task #3
 → Task #5 is now blocked until #3 completes
 → Suggested: Also consider if #5 needs #4

.claude/commands/tm/add-subtask/add-subtask.md

@@ -56,12 +56,12 @@ task-master add-subtask --parent=<id> --task-id=<existing-id>
 ## Example Flows
 
 ```
-/taskmaster:add-subtask to 5: implement user authentication
+/project:tm/add-subtask to 5: implement user authentication
 → Created subtask #5.1: "implement user authentication"
 → Parent task #5 now has 1 subtask
 → Suggested next subtasks: tests, documentation
 
-/taskmaster:add-subtask 5: setup, implement, test
+/project:tm/add-subtask 5: setup, implement, test
 → Created 3 subtasks:
   #5.1: setup
   #5.2: implement  

.claude/commands/tm/add-subtask/convert-task-to-subtask.md

@@ -53,7 +53,7 @@ task-master add-subtask --parent=<parent-id> --task-id=<task-to-convert>
 ## Example
 
 ```
-/taskmaster:add-subtask/from-task 5 8
+/project:tm/add-subtask/from-task 5 8
 → Converting: Task #8 becomes subtask #5.1
 → Updated: 3 dependency references
 → Parent task #5 now has 1 subtask

.claude/commands/tm/analyze-complexity/analyze-complexity.md

@@ -115,7 +115,7 @@ Results are:
 
 After analysis:
 ```
-/taskmaster:expand 5    # Expand specific task
-/taskmaster:expand-all  # Expand all recommended
-/taskmaster:complexity-report  # View detailed report
+/project:tm/expand 5    # Expand specific task
+/project:tm/expand/all  # Expand all recommended
+/project:tm/complexity-report  # View detailed report
 ```

.claude/commands/tm/complexity-report/complexity-report.md

@@ -105,13 +105,13 @@ Use report for:
 ## Example Usage
 
 ```
-/taskmaster:complexity-report
+/project:tm/complexity-report
 → Opens latest analysis
 
-/taskmaster:complexity-report --file=archived/2024-01-01.md
+/project:tm/complexity-report --file=archived/2024-01-01.md
 → View historical analysis
 
 After viewing:
-/taskmaster:expand 5
+/project:tm/expand 5
 → Expand high-complexity task
 ```

.claude/commands/tm/fix-dependencies/fix-dependencies.md

@@ -70,7 +70,7 @@ Manual Review Needed:
 ⚠️ Task #45 has 8 dependencies
   Suggestion: Break into subtasks
 
-Run '/taskmaster:validate-dependencies' to verify fixes
+Run '/project:tm/validate-dependencies' to verify fixes
 ```
 
 ## Safety

.claude/commands/tm/help.md

@@ -0,0 +1,81 @@
+Show help for Task Master commands.
+
+Arguments: $ARGUMENTS
+
+Display help for Task Master commands. If arguments provided, show specific command help.
+
+## Task Master Command Help
+
+### Quick Navigation
+
+Type `/project:tm/` and use tab completion to explore all commands.
+
+### Command Categories
+
+#### 🚀 Setup & Installation
+- `/project:tm/setup/install` - Comprehensive installation guide
+- `/project:tm/setup/quick-install` - One-line global install
+
+#### 📋 Project Setup
+- `/project:tm/init` - Initialize new project
+- `/project:tm/init/quick` - Quick setup with auto-confirm
+- `/project:tm/models` - View AI configuration
+- `/project:tm/models/setup` - Configure AI providers
+
+#### 🎯 Task Generation
+- `/project:tm/parse-prd` - Generate tasks from PRD
+- `/project:tm/parse-prd/with-research` - Enhanced parsing
+- `/project:tm/generate` - Create task files
+
+#### 📝 Task Management
+- `/project:tm/list` - List tasks (natural language filters)
+- `/project:tm/show <id>` - Display task details
+- `/project:tm/add-task` - Create new task
+- `/project:tm/update` - Update tasks naturally
+- `/project:tm/next` - Get next task recommendation
+
+#### 🔄 Status Management
+- `/project:tm/set-status/to-pending <id>`
+- `/project:tm/set-status/to-in-progress <id>`
+- `/project:tm/set-status/to-done <id>`
+- `/project:tm/set-status/to-review <id>`
+- `/project:tm/set-status/to-deferred <id>`
+- `/project:tm/set-status/to-cancelled <id>`
+
+#### 🔍 Analysis & Breakdown
+- `/project:tm/analyze-complexity` - Analyze task complexity
+- `/project:tm/expand <id>` - Break down complex task
+- `/project:tm/expand/all` - Expand all eligible tasks
+
+#### 🔗 Dependencies
+- `/project:tm/add-dependency` - Add task dependency
+- `/project:tm/remove-dependency` - Remove dependency
+- `/project:tm/validate-dependencies` - Check for issues
+
+#### 🤖 Workflows
+- `/project:tm/workflows/smart-flow` - Intelligent workflows
+- `/project:tm/workflows/pipeline` - Command chaining
+- `/project:tm/workflows/auto-implement` - Auto-implementation
+
+#### 📊 Utilities
+- `/project:tm/utils/analyze` - Project analysis
+- `/project:tm/status` - Project dashboard
+- `/project:tm/learn` - Interactive learning
+
+### Natural Language Examples
+
+```
+/project:tm/list pending high priority
+/project:tm/update mark all API tasks as done
+/project:tm/add-task create login system with OAuth
+/project:tm/show current
+```
+
+### Getting Started
+
+1. Install: `/project:tm/setup/quick-install`
+2. Initialize: `/project:tm/init/quick`
+3. Learn: `/project:tm/learn start`
+4. Work: `/project:tm/workflows/smart-flow`
+
+For detailed command info: `/project:tm/help <command-name>`

.claude/commands/tm/init/init-project-quick.md

@@ -30,17 +30,17 @@ task-master init -y
 After quick init:
 1. Configure AI models if needed:
    ```
-   /taskmaster:models/setup
+   /project:tm/models/setup
    ```
 
 2. Parse PRD if available:
    ```
-   /taskmaster:parse-prd <file>
+   /project:tm/parse-prd <file>
    ```
 
 3. Or create first task:
    ```
-   /taskmaster:add-task create initial setup
+   /project:tm/add-task create initial setup
    ```
 
 Perfect for rapid project setup!

.claude/commands/tm/init/init-project.md

@@ -45,6 +45,6 @@ After successful init:
 
 If PRD file provided:
 ```
-/taskmaster:init my-prd.md
+/project:tm/init my-prd.md
 → Automatically runs parse-prd after init
 ```

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

@@ -55,7 +55,7 @@ After removing:
 ## Example
 
 ```
-/taskmaster:remove-dependency 5 from 3
+/project:tm/remove-dependency 5 from 3
 → Removed: Task #5 no longer depends on #3
 → Task #5 is now UNBLOCKED and ready to start
 → Warning: Consider if #5 still needs #2 completed first

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

@@ -63,13 +63,13 @@ task-master remove-subtask --id=<parentId.subtaskId> --convert
 ## Example Flows
 
 ```
-/taskmaster:remove-subtask 5.1
+/project:tm/remove-subtask 5.1
 → Warning: Subtask #5.1 is in-progress
 → This will delete all subtask data
 → Parent task #5 will be updated
 Confirm deletion? (y/n)
 
-/taskmaster:remove-subtask 5.1 convert
+/project:tm/remove-subtask 5.1 convert
 → Converting subtask #5.1 to standalone task #89
 → Preserved: All task data and history
 → Updated: 2 dependency references

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

@@ -77,7 +77,7 @@ Suggest alternatives:
 ## Example
 
 ```
-/taskmaster:clear-subtasks 5
+/project:tm/clear-subtasks 5
 → Found 4 subtasks to remove
 → Warning: Subtask #5.2 is in-progress
 → Cleared all subtasks from task #5

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

@@ -85,17 +85,17 @@ Suggest before deletion:
 ## Example Flows
 
 ```
-/taskmaster:remove-task 5
+/project:tm/remove-task 5
 → Task #5 is in-progress with 8 hours logged
 → 3 other tasks depend on this
 → Suggestion: Mark as cancelled instead?
 Remove anyway? (y/n)
 
-/taskmaster:remove-task 5 -y
+/project:tm/remove-task 5 -y
 → Removed: Task #5 and 4 subtasks
 → Updated: 3 task dependencies
 → Warning: Tasks #7, #8, #9 now have missing dependency
-→ Run /taskmaster:fix-dependencies to resolve
+→ Run /project:tm/fix-dependencies to resolve
 ```
 
 ## Safety Features

.claude/commands/tm/tm-main.md

@@ -8,11 +8,11 @@ Commands are organized hierarchically to match Task Master's CLI structure while
 
 ## Project Setup & Configuration
 
-### `/taskmaster:init`
+### `/project:tm/init`
 - `init-project` - Initialize new project (handles PRD files intelligently)
 - `init-project-quick` - Quick setup with auto-confirmation (-y flag)
 
-### `/taskmaster:models`
+### `/project:tm/models`
 - `view-models` - View current AI model configuration
 - `setup-models` - Interactive model configuration
 - `set-main` - Set primary generation model
@@ -21,21 +21,21 @@ Commands are organized hierarchically to match Task Master's CLI structure while
 
 ## Task Generation
 
-### `/taskmaster:parse-prd`
+### `/project:tm/parse-prd`
 - `parse-prd` - Generate tasks from PRD document
 - `parse-prd-with-research` - Enhanced parsing with research mode
 
-### `/taskmaster:generate`
+### `/project:tm/generate`
 - `generate-tasks` - Create individual task files from tasks.json
 
 ## Task Management
 
-### `/taskmaster:list`
+### `/project:tm/list`
 - `list-tasks` - Smart listing with natural language filters
 - `list-tasks-with-subtasks` - Include subtasks in hierarchical view
 - `list-tasks-by-status` - Filter by specific status
 
-### `/taskmaster:set-status`
+### `/project:tm/set-status`
 - `to-pending` - Reset task to pending
 - `to-in-progress` - Start working on task
 - `to-done` - Mark task complete
@@ -43,84 +43,84 @@ Commands are organized hierarchically to match Task Master's CLI structure while
 - `to-deferred` - Defer task
 - `to-cancelled` - Cancel task
 
-### `/taskmaster:sync-readme`
+### `/project:tm/sync-readme`
 - `sync-readme` - Export tasks to README.md with formatting
 
-### `/taskmaster:update`
+### `/project:tm/update`
 - `update-task` - Update tasks with natural language
 - `update-tasks-from-id` - Update multiple tasks from a starting point
 - `update-single-task` - Update specific task
 
-### `/taskmaster:add-task`
+### `/project:tm/add-task`
 - `add-task` - Add new task with AI assistance
 
-### `/taskmaster:remove-task`
+### `/project:tm/remove-task`
 - `remove-task` - Remove task with confirmation
 
 ## Subtask Management
 
-### `/taskmaster:add-subtask`
+### `/project:tm/add-subtask`
 - `add-subtask` - Add new subtask to parent
 - `convert-task-to-subtask` - Convert existing task to subtask
 
-### `/taskmaster:remove-subtask`
+### `/project:tm/remove-subtask`
 - `remove-subtask` - Remove subtask (with optional conversion)
 
-### `/taskmaster:clear-subtasks`
+### `/project:tm/clear-subtasks`
 - `clear-subtasks` - Clear subtasks from specific task
 - `clear-all-subtasks` - Clear all subtasks globally
 
 ## Task Analysis & Breakdown
 
-### `/taskmaster:analyze-complexity`
+### `/project:tm/analyze-complexity`
 - `analyze-complexity` - Analyze and generate expansion recommendations
 
-### `/taskmaster:complexity-report`
+### `/project:tm/complexity-report`
 - `complexity-report` - Display complexity analysis report
 
-### `/taskmaster:expand`
+### `/project:tm/expand`
 - `expand-task` - Break down specific task
 - `expand-all-tasks` - Expand all eligible tasks
 - `with-research` - Enhanced expansion
 
 ## Task Navigation
 
-### `/taskmaster:next`
+### `/project:tm/next`
 - `next-task` - Intelligent next task recommendation
 
-### `/taskmaster:show`
+### `/project:tm/show`
 - `show-task` - Display detailed task information
 
-### `/taskmaster:status`
+### `/project:tm/status`
 - `project-status` - Comprehensive project dashboard
 
 ## Dependency Management
 
-### `/taskmaster:add-dependency`
+### `/project:tm/add-dependency`
 - `add-dependency` - Add task dependency
 
-### `/taskmaster:remove-dependency`
+### `/project:tm/remove-dependency`
 - `remove-dependency` - Remove task dependency
 
-### `/taskmaster:validate-dependencies`
+### `/project:tm/validate-dependencies`
 - `validate-dependencies` - Check for dependency issues
 
-### `/taskmaster:fix-dependencies`
+### `/project:tm/fix-dependencies`
 - `fix-dependencies` - Automatically fix dependency problems
 
 ## Workflows & Automation
 
-### `/taskmaster:workflows`
+### `/project:tm/workflows`
 - `smart-workflow` - Context-aware intelligent workflow execution
 - `command-pipeline` - Chain multiple commands together
 - `auto-implement-tasks` - Advanced auto-implementation with code generation
 
 ## Utilities
 
-### `/taskmaster:utils`
+### `/project:tm/utils`
 - `analyze-project` - Deep project analysis and insights
 
-### `/taskmaster:setup`
+### `/project:tm/setup`
 - `install-taskmaster` - Comprehensive installation guide
 - `quick-install-taskmaster` - One-line global installation
 
@@ -129,17 +129,17 @@ Commands are organized hierarchically to match Task Master's CLI structure while
 ### Natural Language
 Most commands accept natural language arguments:
 ```
-/taskmaster:add-task create user authentication system
-/taskmaster:update mark all API tasks as high priority
-/taskmaster:list show blocked tasks
+/project:tm/add-task create user authentication system
+/project:tm/update mark all API tasks as high priority
+/project:tm/list show blocked tasks
 ```
 
 ### ID-Based Commands
 Commands requiring IDs intelligently parse from $ARGUMENTS:
 ```
-/taskmaster:show 45
-/taskmaster:expand 23
-/taskmaster:set-status/to-done 67
+/project:tm/show 45
+/project:tm/expand 23
+/project:tm/set-status/to-done 67
 ```
 
 ### Smart Defaults

.claude/commands/tm/update/update-single-task.md

@@ -66,7 +66,7 @@ The AI:
 ## Example Updates
 
 ```
-/taskmaster:update/single 5: add rate limiting
+/project:tm/update/single 5: add rate limiting
 → Updating Task #5: "Implement API endpoints"
 
 Current: Basic CRUD endpoints

.claude/commands/tm/update/update-tasks-from-id.md

@@ -77,7 +77,7 @@ AI analyzes the update context and:
 ## Example Updates
 
 ```
-/taskmaster:update/from-id 5: change database to PostgreSQL
+/project:tm/update/from-id 5: change database to PostgreSQL
 → Analyzing impact starting from task #5
 → Found 6 related tasks to update
 → Updates will maintain consistency

.claude/commands/tm/validate-dependencies/validate-dependencies.md

@@ -66,6 +66,6 @@ For each issue found:
 ## Next Steps
 
 After validation:
-- Run `/taskmaster:fix-dependencies` to auto-fix
+- Run `/project:tm/fix-dependencies` to auto-fix
 - Manually adjust problematic dependencies
 - Rerun to verify fixes

.env.example

@@ -14,4 +14,4 @@ OLLAMA_API_KEY=YOUR_OLLAMA_API_KEY_HERE
 VERTEX_PROJECT_ID=your-gcp-project-id
 VERTEX_LOCATION=us-central1
 # Optional: Path to service account credentials JSON file (alternative to API key)
-GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-credentials.json
+GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-credentials.json

CHANGELOG.md

@@ -1,175 +1,5 @@
 # task-master-ai
 
-## 0.29.0
-
-### Minor Changes
-
-- [#1286](https://github.com/eyaltoledano/claude-task-master/pull/1286) [`f12a16d`](https://github.com/eyaltoledano/claude-task-master/commit/f12a16d09649f62148515f11f616157c7d0bd2d5) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add changelog highlights to auto-update notifications
-
-  When the CLI auto-updates to a new version, it now displays a "What's New" section.
-
-- [#1293](https://github.com/eyaltoledano/claude-task-master/pull/1293) [`3010b90`](https://github.com/eyaltoledano/claude-task-master/commit/3010b90d98f3a7d8636caa92fc33d6ee69d4bed0) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Claude Code plugin with marketplace distribution
-
-  This release introduces official Claude Code plugin support, marking the evolution from legacy `.claude` directory copying to a modern plugin-based architecture.
-
-  ## 🎉 New: Claude Code Plugin
-
-  Task Master AI commands and agents are now distributed as a proper Claude Code plugin:
-  - **49 slash commands** with clean naming (`/taskmaster:command-name`)
-  - **3 specialized AI agents** (task-orchestrator, task-executor, task-checker)
-  - **MCP server integration** for deep Claude Code integration
-
-  **Installation:**
-
-  ```bash
-  /plugin marketplace add eyaltoledano/claude-task-master
-  /plugin install taskmaster@taskmaster
-  ```
-
-  ### The `rules add claude` command no longer copies commands and agents to `.claude/commands/` and `.claude/agents/`. Instead, it now
-  - Shows plugin installation instructions
-  - Only manages CLAUDE.md imports for agent instructions
-  - Directs users to install the official plugin
-
-  **Migration for Existing Users:**
-
-  If you previously used `rules add claude`:
-  1. The old commands in `.claude/commands/` will continue to work but won't receive updates
-  2. Install the plugin for the latest features: `/plugin install taskmaster@taskmaster`
-  3. remove old `.claude/commands/` and `.claude/agents/` directories
-
-  **Why This Change?**
-
-  Claude Code plugins provide:
-  - ✅ Automatic updates when we release new features
-  - ✅ Better command organization and naming
-  - ✅ Seamless integration with Claude Code
-  - ✅ No manual file copying or management
-
-  The plugin system is the future of Task Master AI integration with Claude Code!
-
-- [#1285](https://github.com/eyaltoledano/claude-task-master/pull/1285) [`2a910a4`](https://github.com/eyaltoledano/claude-task-master/commit/2a910a40bac375f9f61d797bf55597303d556b48) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add RPG (Repository Planning Graph) method template for structured PRD creation. The new `example_prd_rpg.txt` template teaches AI agents and developers the RPG methodology through embedded instructions, inline good/bad examples, and XML-style tags for structure. This template enables creation of dependency-aware PRDs that automatically generate topologically-ordered task graphs when parsed with Task Master.
-
-  Key features:
-  - Method-as-template: teaches RPG principles (dual-semantics, explicit dependencies, topological order) while being used
-  - Inline instructions at decision points guide AI through each section
-  - Good/bad examples for immediate pattern matching
-  - Flexible plain-text format with XML-style tags for parseability
-  - Critical dependency-graph section ensures correct task ordering
-  - Automatic inclusion during `task-master init`
-  - Comprehensive documentation at [docs.task-master.dev/capabilities/rpg-method](https://docs.task-master.dev/capabilities/rpg-method)
-  - Tool recommendations for code-context-aware PRD creation (Claude Code, Cursor, Gemini CLI, Codex/Grok)
-
-  The RPG template complements the existing `example_prd.txt` and provides a more structured approach for complex projects requiring clear module boundaries and dependency chains.
-
-- [#1287](https://github.com/eyaltoledano/claude-task-master/pull/1287) [`90e6bdc`](https://github.com/eyaltoledano/claude-task-master/commit/90e6bdcf1c59f65ad27fcdfe3b13b9dca7e77654) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Enhance `expand_all` to intelligently use complexity analysis recommendations when expanding tasks.
-
-  The expand-all operation now automatically leverages recommendations from `analyze-complexity` to determine optimal subtask counts for each task, resulting in more accurate and context-aware task breakdowns.
-
-  Key improvements:
-  - Automatic integration with complexity analysis reports
-  - Tag-aware complexity report path resolution
-  - Intelligent subtask count determination based on task complexity
-  - Falls back to defaults when complexity analysis is unavailable
-  - Enhanced logging for better visibility into expansion decisions
-
-  When you run `task-master expand --all` after `task-master analyze-complexity`, Task Master now uses the recommended subtask counts from the complexity analysis instead of applying uniform defaults, ensuring each task is broken down according to its actual complexity.
-
-### Patch Changes
-
-- [#1191](https://github.com/eyaltoledano/claude-task-master/pull/1191) [`aaf903f`](https://github.com/eyaltoledano/claude-task-master/commit/aaf903ff2f606c779a22e9a4b240ab57b3683815) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix cross-level task dependencies not being saved
-
-  Fixes an issue where adding dependencies between subtasks and top-level tasks (e.g., `task-master add-dependency --id=2.2 --depends-on=11`) would report success but fail to persist the changes. Dependencies can now be created in both directions between any task levels.
-
-- [#1299](https://github.com/eyaltoledano/claude-task-master/pull/1299) [`4c1ef2c`](https://github.com/eyaltoledano/claude-task-master/commit/4c1ef2ca94411c53bcd2a78ec710b06c500236dd) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve refresh token when authenticating
-
-## 0.29.0-rc.1
-
-### Patch Changes
-
-- [#1299](https://github.com/eyaltoledano/claude-task-master/pull/1299) [`a6c5152`](https://github.com/eyaltoledano/claude-task-master/commit/a6c5152f20edd8717cf1aea34e7c178b1261aa99) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve refresh token when authenticating
-
-## 0.29.0-rc.0
-
-### Minor Changes
-
-- [#1286](https://github.com/eyaltoledano/claude-task-master/pull/1286) [`f12a16d`](https://github.com/eyaltoledano/claude-task-master/commit/f12a16d09649f62148515f11f616157c7d0bd2d5) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add changelog highlights to auto-update notifications
-
-  When the CLI auto-updates to a new version, it now displays a "What's New" section.
-
-- [#1293](https://github.com/eyaltoledano/claude-task-master/pull/1293) [`3010b90`](https://github.com/eyaltoledano/claude-task-master/commit/3010b90d98f3a7d8636caa92fc33d6ee69d4bed0) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Claude Code plugin with marketplace distribution
-
-  This release introduces official Claude Code plugin support, marking the evolution from legacy `.claude` directory copying to a modern plugin-based architecture.
-
-  ## 🎉 New: Claude Code Plugin
-
-  Task Master AI commands and agents are now distributed as a proper Claude Code plugin:
-  - **49 slash commands** with clean naming (`/task-master-ai:command-name`)
-  - **3 specialized AI agents** (task-orchestrator, task-executor, task-checker)
-  - **MCP server integration** for deep Claude Code integration
-
-  **Installation:**
-
-  ```bash
-  /plugin marketplace add eyaltoledano/claude-task-master
-  /plugin install taskmaster@taskmaster
-  ```
-
-  ### The `rules add claude` command no longer copies commands and agents to `.claude/commands/` and `.claude/agents/`. Instead, it now
-  - Shows plugin installation instructions
-  - Only manages CLAUDE.md imports for agent instructions
-  - Directs users to install the official plugin
-
-  **Migration for Existing Users:**
-
-  If you previously used `rules add claude`:
-  1. The old commands in `.claude/commands/` will continue to work but won't receive updates
-  2. Install the plugin for the latest features: `/plugin install taskmaster@taskmaster`
-  3. remove old `.claude/commands/` and `.claude/agents/` directories
-
-  **Why This Change?**
-
-  Claude Code plugins provide:
-  - ✅ Automatic updates when we release new features
-  - ✅ Better command organization and naming
-  - ✅ Seamless integration with Claude Code
-  - ✅ No manual file copying or management
-
-  The plugin system is the future of Task Master AI integration with Claude Code!
-
-- [#1285](https://github.com/eyaltoledano/claude-task-master/pull/1285) [`2a910a4`](https://github.com/eyaltoledano/claude-task-master/commit/2a910a40bac375f9f61d797bf55597303d556b48) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add RPG (Repository Planning Graph) method template for structured PRD creation. The new `example_prd_rpg.txt` template teaches AI agents and developers the RPG methodology through embedded instructions, inline good/bad examples, and XML-style tags for structure. This template enables creation of dependency-aware PRDs that automatically generate topologically-ordered task graphs when parsed with Task Master.
-
-  Key features:
-  - Method-as-template: teaches RPG principles (dual-semantics, explicit dependencies, topological order) while being used
-  - Inline instructions at decision points guide AI through each section
-  - Good/bad examples for immediate pattern matching
-  - Flexible plain-text format with XML-style tags for parseability
-  - Critical dependency-graph section ensures correct task ordering
-  - Automatic inclusion during `task-master init`
-  - Comprehensive documentation at [docs.task-master.dev/capabilities/rpg-method](https://docs.task-master.dev/capabilities/rpg-method)
-  - Tool recommendations for code-context-aware PRD creation (Claude Code, Cursor, Gemini CLI, Codex/Grok)
-
-  The RPG template complements the existing `example_prd.txt` and provides a more structured approach for complex projects requiring clear module boundaries and dependency chains.
-
-- [#1287](https://github.com/eyaltoledano/claude-task-master/pull/1287) [`90e6bdc`](https://github.com/eyaltoledano/claude-task-master/commit/90e6bdcf1c59f65ad27fcdfe3b13b9dca7e77654) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Enhance `expand_all` to intelligently use complexity analysis recommendations when expanding tasks.
-
-  The expand-all operation now automatically leverages recommendations from `analyze-complexity` to determine optimal subtask counts for each task, resulting in more accurate and context-aware task breakdowns.
-
-  Key improvements:
-  - Automatic integration with complexity analysis reports
-  - Tag-aware complexity report path resolution
-  - Intelligent subtask count determination based on task complexity
-  - Falls back to defaults when complexity analysis is unavailable
-  - Enhanced logging for better visibility into expansion decisions
-
-  When you run `task-master expand --all` after `task-master analyze-complexity`, Task Master now uses the recommended subtask counts from the complexity analysis instead of applying uniform defaults, ensuring each task is broken down according to its actual complexity.
-
-### Patch Changes
-
-- [#1191](https://github.com/eyaltoledano/claude-task-master/pull/1191) [`aaf903f`](https://github.com/eyaltoledano/claude-task-master/commit/aaf903ff2f606c779a22e9a4b240ab57b3683815) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix cross-level task dependencies not being saved
-
-  Fixes an issue where adding dependencies between subtasks and top-level tasks (e.g., `task-master add-dependency --id=2.2 --depends-on=11`) would report success but fail to persist the changes. Dependencies can now be created in both directions between any task levels.
-
 ## 0.28.0
 
 ### Minor Changes

CLAUDE_CODE_PLUGIN.md

@@ -1,140 +0,0 @@
-# Taskmaster AI - Claude Code Marketplace
-
-This repository includes a Claude Code plugin marketplace in `.claude-plugin/marketplace.json`.
-
-## Installation
-
-### From GitHub (Public Repository)
-
-Once this repository is pushed to GitHub, users can install with:
-
-```bash
-# Add the marketplace
-/plugin marketplace add eyaltoledano/claude-task-master
-
-# Install the plugin
-/plugin install taskmaster@taskmaster
-```
-
-### Local Development/Testing
-
-```bash
-# From the project root directory
-cd /path/to/claude-task-master
-
-# Build the plugin first
-cd packages/claude-code-plugin
-npm run build
-cd ../..
-
-# In Claude Code
-/plugin marketplace add .
-/plugin install taskmaster@taskmaster
-```
-
-## Marketplace Structure
-
-```
-claude-task-master/
-├── .claude-plugin/
-│   └── marketplace.json        # Marketplace manifest (at repo root)
-│
-├── packages/claude-code-plugin/
-│   ├── src/build.ts           # Build tooling
-│   └── [generated plugin files]
-│
-└── assets/claude/              # Plugin source files
-    ├── commands/
-    └── agents/
-```
-
-## Available Plugins
-
-### taskmaster
-
-AI-powered task management system for ambitious development workflows.
-
-**Features:**
-
-- 49 slash commands for comprehensive task management
-- 3 specialized AI agents (orchestrator, executor, checker)
-- MCP server integration
-- Complexity analysis and auto-expansion
-- Dependency management and validation
-- Automated workflow capabilities
-
-**Quick Start:**
-
-```bash
-/tm:init
-/tm:parse-prd
-/tm:next
-```
-
-## For Contributors
-
-### Adding New Plugins
-
-To add more plugins to this marketplace:
-
-1. **Update marketplace.json**:
-
-   ```json
-   {
-     "plugins": [
-       {
-         "name": "new-plugin",
-         "source": "./path/to/plugin",
-         "description": "Plugin description",
-         "version": "1.0.0"
-       }
-     ]
-   }
-   ```
-
-2. **Commit and push** the changes
-
-3. **Users update** with: `/plugin marketplace update taskmaster`
-
-### Marketplace Versioning
-
-The marketplace version is tracked in `.claude-plugin/marketplace.json`:
-
-```json
-{
-  "metadata": {
-    "version": "1.0.0"
-  }
-}
-```
-
-Increment the version when adding or updating plugins.
-
-## Team Configuration
-
-Organizations can auto-install this marketplace for all team members by adding to `.claude/settings.json`:
-
-```json
-{
-  "extraKnownMarketplaces": {
-    "task-master": {
-      "source": {
-        "source": "github",
-        "repo": "eyaltoledano/claude-task-master"
-      }
-    }
-  },
-  "enabledPlugins": {
-    "taskmaster": {
-      "marketplace": "taskmaster"
-    }
-  }
-}
-```
-
-Team members who trust the repository folder will automatically get the marketplace and plugins installed.
-
-## Documentation
-
-- [Claude Code Plugin Docs](https://docs.claude.com/en/docs/claude-code/plugins)
-- [Marketplace Documentation](https://docs.claude.com/en/docs/claude-code/plugin-marketplaces)

README.md

@@ -119,7 +119,6 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
       "command": "npx",
       "args": ["-y", "task-master-ai"],
       "env": {
-        // "TASK_MASTER_TOOLS": "all", // Options: "all", "standard", "core", or comma-separated list of tools
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
         "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
@@ -149,7 +148,6 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
       "command": "npx",
       "args": ["-y", "task-master-ai"],
       "env": {
-        // "TASK_MASTER_TOOLS": "all", // Options: "all", "standard", "core", or comma-separated list of tools
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
         "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
@@ -198,7 +196,7 @@ Initialize taskmaster-ai in my project
 
 #### 5. Make sure you have a PRD (Recommended)
 
-For **new projects**: Create your PRD at `.taskmaster/docs/prd.txt`.
+For **new projects**: Create your PRD at `.taskmaster/docs/prd.txt`  
 For **existing projects**: You can use `scripts/prd.txt` or migrate with `task-master migrate`
 
 An example PRD template is available after initialization in `.taskmaster/templates/example_prd.txt`.
@@ -284,76 +282,6 @@ task-master generate
 task-master rules add windsurf,roo,vscode
 ```
 
-## Tool Loading Configuration
-
-### Optimizing MCP Tool Loading
-
-Task Master's MCP server supports selective tool loading to reduce context window usage. By default, all 36 tools are loaded (~21,000 tokens) to maintain backward compatibility with existing installations.
-
-You can optimize performance by configuring the `TASK_MASTER_TOOLS` environment variable:
-
-### Available Modes
-
-| Mode | Tools | Context Usage | Use Case |
-|------|-------|--------------|----------|
-| `all` (default) | 36 | ~21,000 tokens | Complete feature set - all tools available |
-| `standard` | 15 | ~10,000 tokens | Common task management operations |
-| `core` (or `lean`) | 7 | ~5,000 tokens | Essential daily development workflow |
-| `custom` | Variable | Variable | Comma-separated list of specific tools |
-
-### Configuration Methods
-
-#### Method 1: Environment Variable in MCP Configuration
-
-Add `TASK_MASTER_TOOLS` to your MCP configuration file's `env` section:
-
-```jsonc
-{
-  "mcpServers": {  // or "servers" for VS Code
-    "task-master-ai": {
-      "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
-      "env": {
-        "TASK_MASTER_TOOLS": "standard",  // Options: "all", "standard", "core", "lean", or comma-separated list
-        "ANTHROPIC_API_KEY": "your-key-here",
-        // ... other API keys
-      }
-    }
-  }
-}
-```
-
-#### Method 2: Claude Code CLI (One-Time Setup)
-
-For Claude Code users, you can set the mode during installation:
-
-```bash
-# Core mode example (~70% token reduction)
-claude mcp add task-master-ai --scope user \
-  --env TASK_MASTER_TOOLS="core" \
-  -- npx -y task-master-ai@latest
-
-# Custom tools example
-claude mcp add task-master-ai --scope user \
-  --env TASK_MASTER_TOOLS="get_tasks,next_task,set_task_status" \
-  -- npx -y task-master-ai@latest
-```
-
-### Tool Sets Details
-
-**Core Tools (7):** `get_tasks`, `next_task`, `get_task`, `set_task_status`, `update_subtask`, `parse_prd`, `expand_task`
-
-**Standard Tools (15):** All core tools plus `initialize_project`, `analyze_project_complexity`, `expand_all`, `add_subtask`, `remove_task`, `generate`, `add_task`, `complexity_report`
-
-**All Tools (36):** Complete set including project setup, task management, analysis, dependencies, tags, research, and more
-
-### Recommendations
-
-- **New users**: Start with `"standard"` mode for a good balance
-- **Large projects**: Use `"core"` mode to minimize token usage
-- **Complex workflows**: Use `"all"` mode or custom selection
-- **Backward compatibility**: If not specified, defaults to `"all"` mode
-
 ## Claude Code Support
 
 Task Master now supports Claude models through the Claude Code CLI, which requires no API key:
@@ -382,12 +310,6 @@ cd claude-task-master
 node scripts/init.js
 ```
 
-## Join Our Team
-
-<a href="https://tryhamster.com" target="_blank">
-  <img src="./images/hamster-hiring.png" alt="Join Hamster's founding team" />
-</a>
-
 ## Contributors
 
 <a href="https://github.com/eyaltoledano/claude-task-master/graphs/contributors">

apps/cli/CHANGELOG.md

@@ -11,13 +11,6 @@
 
 ### Patch Changes
 
-- Updated dependencies []:
-  - @tm/core@null
-
-## null
-
-### Patch Changes
-
 - Updated dependencies []:
   - @tm/core@null
 

apps/cli/package.json

@@ -22,7 +22,6 @@
 		"test:ci": "vitest run --coverage --reporter=dot"
 	},
 	"dependencies": {
-		"@inquirer/search": "^3.2.0",
 		"@tm/core": "*",
 		"boxen": "^8.0.1",
 		"chalk": "5.6.2",

apps/cli/src/command-registry.ts

@@ -8,7 +8,6 @@ import { Command } from 'commander';
 // Import all commands
 import { ListTasksCommand } from './commands/list.command.js';
 import { ShowCommand } from './commands/show.command.js';
-import { NextCommand } from './commands/next.command.js';
 import { AuthCommand } from './commands/auth.command.js';
 import { ContextCommand } from './commands/context.command.js';
 import { StartCommand } from './commands/start.command.js';
@@ -46,12 +45,6 @@ export class CommandRegistry {
 			commandClass: ShowCommand as any,
 			category: 'task'
 		},
-		{
-			name: 'next',
-			description: 'Find the next available task to work on',
-			commandClass: NextCommand as any,
-			category: 'task'
-		},
 		{
 			name: 'start',
 			description: 'Start working on a task with claude-code',

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

@@ -14,8 +14,6 @@ import {
 	type AuthCredentials
 } from '@tm/core/auth';
 import * as ui from '../utils/ui.js';
-import { ContextCommand } from './context.command.js';
-import { displayError } from '../utils/error-handler.js';
 
 /**
  * Result type from auth command
@@ -118,7 +116,8 @@ export class AuthCommand extends Command {
 				process.exit(0);
 			}, 100);
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -134,7 +133,8 @@ export class AuthCommand extends Command {
 				process.exit(1);
 			}
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -146,7 +146,8 @@ export class AuthCommand extends Command {
 			const result = this.displayStatus();
 			this.setLastResult(result);
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -162,7 +163,8 @@ export class AuthCommand extends Command {
 				process.exit(1);
 			}
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -185,29 +187,19 @@ export class AuthCommand extends Command {
 			if (credentials.expiresAt) {
 				const expiresAt = new Date(credentials.expiresAt);
 				const now = new Date();
-				const timeRemaining = expiresAt.getTime() - now.getTime();
-				const hoursRemaining = Math.floor(timeRemaining / (1000 * 60 * 60));
-				const minutesRemaining = Math.floor(timeRemaining / (1000 * 60));
+				const hoursRemaining = Math.floor(
+					(expiresAt.getTime() - now.getTime()) / (1000 * 60 * 60)
+				);
 
-				if (timeRemaining > 0) {
-					// Token is still valid
-					if (hoursRemaining > 0) {
-						console.log(
-							chalk.gray(
-								`  Expires at: ${expiresAt.toLocaleString()} (${hoursRemaining} hours remaining)`
-							)
-						);
-					} else {
-						console.log(
-							chalk.gray(
-								`  Expires at: ${expiresAt.toLocaleString()} (${minutesRemaining} minutes remaining)`
-							)
-						);
-					}
-				} else {
-					// Token has expired
+				if (hoursRemaining > 0) {
 					console.log(
-						chalk.yellow(`  Expired at: ${expiresAt.toLocaleString()}`)
+						chalk.gray(
+							`  Expires: ${expiresAt.toLocaleString()} (${hoursRemaining} hours remaining)`
+						)
+					);
+				} else {
+					console.log(
+						chalk.yellow(`  Token expired at: ${expiresAt.toLocaleString()}`)
 					);
 				}
 			} else {
@@ -349,37 +341,6 @@ export class AuthCommand extends Command {
 				chalk.gray(`  Logged in as: ${credentials.email || credentials.userId}`)
 			);
 
-			// Post-auth: Set up workspace context
-			console.log(); // Add spacing
-			try {
-				const contextCommand = new ContextCommand();
-				const contextResult = await contextCommand.setupContextInteractive();
-				if (contextResult.success) {
-					if (contextResult.orgSelected && contextResult.briefSelected) {
-						console.log(
-							chalk.green('✓ Workspace context configured successfully')
-						);
-					} else if (contextResult.orgSelected) {
-						console.log(chalk.green('✓ Organization selected'));
-					}
-				} else {
-					console.log(
-						chalk.yellow('⚠ Context setup was skipped or encountered issues')
-					);
-					console.log(
-						chalk.gray('  You can set up context later with "tm context"')
-					);
-				}
-			} catch (contextError) {
-				console.log(chalk.yellow('⚠ Context setup encountered an error'));
-				console.log(
-					chalk.gray('  You can set up context later with "tm context"')
-				);
-				if (process.env.DEBUG) {
-					console.error(chalk.gray((contextError as Error).message));
-				}
-			}
-
 			return {
 				success: true,
 				action: 'login',
@@ -387,7 +348,7 @@ export class AuthCommand extends Command {
 				message: 'Authentication successful'
 			};
 		} catch (error) {
-			displayError(error, { skipExit: true });
+			this.handleAuthError(error as AuthenticationError);
 
 			return {
 				success: false,
@@ -450,6 +411,51 @@ export class AuthCommand extends Command {
 		}
 	}
 
+	/**
+	 * 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
 	 */

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

@@ -6,11 +6,13 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import search from '@inquirer/search';
 import ora, { Ora } from 'ora';
-import { AuthManager, type UserContext } from '@tm/core/auth';
+import {
+	AuthManager,
+	AuthenticationError,
+	type UserContext
+} from '@tm/core/auth';
 import * as ui from '../utils/ui.js';
-import { displayError } from '../utils/error-handler.js';
 
 /**
  * Result type from context command
@@ -116,7 +118,8 @@ export class ContextCommand extends Command {
 			const result = this.displayContext();
 			this.setLastResult(result);
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -153,14 +156,10 @@ export class ContextCommand extends Command {
 
 			if (context.briefName || context.briefId) {
 				console.log(chalk.green('\n✓ Brief'));
-				if (context.briefName && context.briefId) {
-					const shortId = context.briefId.slice(0, 8);
-					console.log(
-						chalk.white(`  ${context.briefName} `) + chalk.gray(`(${shortId})`)
-					);
-				} else if (context.briefName) {
+				if (context.briefName) {
 					console.log(chalk.white(`  ${context.briefName}`));
-				} else if (context.briefId) {
+				}
+				if (context.briefId) {
 					console.log(chalk.gray(`  ID: ${context.briefId}`));
 				}
 			}
@@ -212,7 +211,8 @@ export class ContextCommand extends Command {
 				process.exit(1);
 			}
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -250,10 +250,9 @@ export class ContextCommand extends Command {
 			]);
 
 			// Update context
-			this.authManager.updateContext({
+			await this.authManager.updateContext({
 				orgId: selectedOrg.id,
 				orgName: selectedOrg.name,
-				orgSlug: selectedOrg.slug,
 				// Clear brief when changing org
 				briefId: undefined,
 				briefName: undefined
@@ -300,7 +299,8 @@ export class ContextCommand extends Command {
 				process.exit(1);
 			}
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -324,54 +324,26 @@ export class ContextCommand extends Command {
 				};
 			}
 
-			// Prompt for selection with search
-			const selectedBrief = await search<(typeof briefs)[0] | null>({
-				message: 'Search for a brief:',
-				source: async (input) => {
-					const searchTerm = input?.toLowerCase() || '';
-
-					// Static option for no brief
-					const noBriefOption = {
-						name: '(No brief - organization level)',
-						value: null as any,
-						description: 'Clear brief selection'
-					};
-
-					// Filter and map brief options
-					const briefOptions = briefs
-						.filter((brief) => {
-							if (!searchTerm) return true;
-
-							const title = brief.document?.title || '';
-							const shortId = brief.id.slice(0, 8);
-
-							// Search by title first, then by UUID
-							return (
-								title.toLowerCase().includes(searchTerm) ||
-								brief.id.toLowerCase().includes(searchTerm) ||
-								shortId.toLowerCase().includes(searchTerm)
-							);
-						})
-						.map((brief) => {
-							const title =
-								brief.document?.title || `Brief ${brief.id.slice(0, 8)}`;
-							const shortId = brief.id.slice(0, 8);
-							return {
-								name: `${title} ${chalk.gray(`(${shortId})`)}`,
-								value: brief
-							};
-						});
-
-					return [noBriefOption, ...briefOptions];
+			// 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 =
-					selectedBrief.document?.title ||
-					`Brief ${selectedBrief.id.slice(0, 8)}`;
-				this.authManager.updateContext({
+				const briefName = `Brief ${selectedBrief.id.slice(0, 8)}`;
+				await this.authManager.updateContext({
 					briefId: selectedBrief.id,
 					briefName: briefName
 				});
@@ -382,11 +354,11 @@ export class ContextCommand extends Command {
 					success: true,
 					action: 'select-brief',
 					context: this.authManager.getContext() || undefined,
-					message: `Selected brief: ${selectedBrief.document?.title}`
+					message: `Selected brief: ${selectedBrief.name}`
 				};
 			} else {
 				// Clear brief selection
-				this.authManager.updateContext({
+				await this.authManager.updateContext({
 					briefId: undefined,
 					briefName: undefined
 				});
@@ -424,7 +396,8 @@ export class ContextCommand extends Command {
 				process.exit(1);
 			}
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -470,7 +443,8 @@ export class ContextCommand extends Command {
 				process.exit(1);
 			}
 		} catch (error: any) {
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -494,7 +468,7 @@ export class ContextCommand extends Command {
 			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_BASE_DOMAIN || process.env.TM_PUBLIC_BASE_DOMAIN}/home/hamster/briefs/<id>`
+					`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);
 			}
@@ -506,24 +480,20 @@ export class ContextCommand extends Command {
 				process.exit(1);
 			}
 
-			// Fetch org to get a friendly name and slug (optional)
+			// Fetch org to get a friendly name (optional)
 			let orgName: string | undefined;
-			let orgSlug: string | undefined;
 			try {
 				const org = await this.authManager.getOrganization(brief.accountId);
 				orgName = org?.name;
-				orgSlug = org?.slug;
 			} catch {
 				// Non-fatal if org lookup fails
 			}
 
 			// Update context: set org and brief
-			const briefName =
-				brief.document?.title || `Brief ${brief.id.slice(0, 8)}`;
-			this.authManager.updateContext({
+			const briefName = `Brief ${brief.id.slice(0, 8)}`;
+			await this.authManager.updateContext({
 				orgId: brief.accountId,
 				orgName,
-				orgSlug,
 				briefId: brief.id,
 				briefName
 			});
@@ -545,7 +515,8 @@ export class ContextCommand extends Command {
 			try {
 				if (spinner?.isSpinning) spinner.stop();
 			} catch {}
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -642,7 +613,7 @@ export class ContextCommand extends Command {
 				};
 			}
 
-			this.authManager.updateContext(context);
+			await this.authManager.updateContext(context);
 			ui.displaySuccess('Context updated');
 
 			// Display what was set
@@ -674,6 +645,26 @@ export class ContextCommand extends Command {
 		}
 	}
 
+	/**
+	 * 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
 	 */
@@ -695,53 +686,6 @@ export class ContextCommand extends Command {
 		return this.authManager.getContext();
 	}
 
-	/**
-	 * Interactive context setup (for post-auth flow)
-	 * Prompts user to select org and brief
-	 */
-	async setupContextInteractive(): Promise<{
-		success: boolean;
-		orgSelected: boolean;
-		briefSelected: boolean;
-	}> {
-		try {
-			// Ask if user wants to set up workspace context
-			const { setupContext } = await inquirer.prompt([
-				{
-					type: 'confirm',
-					name: 'setupContext',
-					message: 'Would you like to set up your workspace context now?',
-					default: true
-				}
-			]);
-
-			if (!setupContext) {
-				return { success: true, orgSelected: false, briefSelected: false };
-			}
-
-			// Select organization
-			const orgResult = await this.selectOrganization();
-			if (!orgResult.success || !orgResult.context?.orgId) {
-				return { success: false, orgSelected: false, briefSelected: false };
-			}
-
-			// Select brief
-			const briefResult = await this.selectBrief(orgResult.context.orgId);
-			return {
-				success: true,
-				orgSelected: true,
-				briefSelected: briefResult.success
-			};
-		} catch (error) {
-			console.error(
-				chalk.yellow(
-					'\nContext setup skipped due to error. You can set it up later with "tm context"'
-				)
-			);
-			return { success: false, orgSelected: false, briefSelected: false };
-		}
-	}
-
 	/**
 	 * Clean up resources
 	 */

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

@@ -7,10 +7,13 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import ora, { Ora } from 'ora';
-import { AuthManager, type UserContext } from '@tm/core/auth';
+import {
+	AuthManager,
+	AuthenticationError,
+	type UserContext
+} from '@tm/core/auth';
 import { TaskMasterCore, type ExportResult } from '@tm/core';
 import * as ui from '../utils/ui.js';
-import { displayError } from '../utils/error-handler.js';
 
 /**
  * Result type from export command
@@ -100,7 +103,7 @@ export class ExportCommand extends Command {
 			await this.initializeServices();
 
 			// Get current context
-			const context = await this.authManager.getContext();
+			const context = this.authManager.getContext();
 
 			// Determine org and brief IDs
 			let orgId = options?.org || context?.orgId;
@@ -194,7 +197,8 @@ export class ExportCommand extends Command {
 			};
 		} catch (error: any) {
 			if (spinner?.isSpinning) spinner.fail('Export failed');
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -330,6 +334,26 @@ export class ExportCommand extends Command {
 		return confirmed;
 	}
 
+	/**
+	 * 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));
+			}
+		}
+	}
+
 	/**
 	 * Get the last export result (useful for testing)
 	 */

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

@@ -17,9 +17,8 @@ import {
 } from '@tm/core';
 import type { StorageType } from '@tm/core/types';
 import * as ui from '../utils/ui.js';
-import { displayError } from '../utils/error-handler.js';
-import { displayCommandHeader } from '../utils/display-helpers.js';
 import {
+	displayHeader,
 	displayDashboards,
 	calculateTaskStatistics,
 	calculateSubtaskStatistics,
@@ -107,7 +106,14 @@ export class ListTasksCommand extends Command {
 				this.displayResults(result, options);
 			}
 		} catch (error: any) {
-			displayError(error);
+			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);
 		}
 	}
 
@@ -251,12 +257,15 @@ export class ListTasksCommand extends Command {
 	 * Display in text format with tables
 	 */
 	private displayText(data: ListTasksResult, withSubtasks?: boolean): void {
-		const { tasks, tag, storageType } = data;
+		const { tasks, tag } = data;
 
-		// Display header using utility function
-		displayCommandHeader(this.tmCore, {
+		// 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',
-			storageType
+			filePath: filePath
 		});
 
 		// No tasks message

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

@@ -1,248 +0,0 @@
-/**
- * @fileoverview NextCommand using Commander's native class pattern
- * Extends Commander.Command for better integration with the framework
- */
-
-import path from 'node:path';
-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 { displayError } from '../utils/error-handler.js';
-import { displayTaskDetails } from '../ui/components/task-detail.component.js';
-import { displayCommandHeader } from '../utils/display-helpers.js';
-
-/**
- * Options interface for the next command
- */
-export interface NextCommandOptions {
-	tag?: string;
-	format?: 'text' | 'json';
-	silent?: boolean;
-	project?: string;
-}
-
-/**
- * Result type from next command
- */
-export interface NextTaskResult {
-	task: Task | null;
-	found: boolean;
-	tag: string;
-	storageType: Exclude<StorageType, 'auto'>;
-}
-
-/**
- * NextCommand extending Commander's Command class
- * This is a thin presentation layer over @tm/core
- */
-export class NextCommand extends Command {
-	private tmCore?: TaskMasterCore;
-	private lastResult?: NextTaskResult;
-
-	constructor(name?: string) {
-		super(name || 'next');
-
-		// Configure the command
-		this.description('Find the next available task to work on')
-			.option('-t, --tag <tag>', 'Filter by tag')
-			.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: NextCommandOptions) => {
-				await this.executeCommand(options);
-			});
-	}
-
-	/**
-	 * Execute the next command
-	 */
-	private async executeCommand(options: NextCommandOptions): Promise<void> {
-		let hasError = false;
-		try {
-			// Validate options (throws on invalid options)
-			this.validateOptions(options);
-
-			// Initialize tm-core
-			await this.initializeCore(options.project || process.cwd());
-
-			// Get next task from core
-			const result = await this.getNextTask(options);
-
-			// Store result for programmatic access
-			this.setLastResult(result);
-
-			// Display results
-			if (!options.silent) {
-				this.displayResults(result, options);
-			}
-		} catch (error: any) {
-			hasError = true;
-			displayError(error, { skipExit: true });
-		} finally {
-			// Always clean up resources, even on error
-			await this.cleanup();
-		}
-
-		// Exit after cleanup completes
-		if (hasError) {
-			process.exit(1);
-		}
-	}
-
-	/**
-	 * Validate command options
-	 */
-	private validateOptions(options: NextCommandOptions): void {
-		// Validate format
-		if (options.format && !['text', 'json'].includes(options.format)) {
-			throw new Error(
-				`Invalid format: ${options.format}. Valid formats are: text, json`
-			);
-		}
-	}
-
-	/**
-	 * Initialize TaskMasterCore
-	 */
-	private async initializeCore(projectRoot: string): Promise<void> {
-		if (!this.tmCore) {
-			const resolved = path.resolve(projectRoot);
-			this.tmCore = await createTaskMasterCore({ projectPath: resolved });
-		}
-	}
-
-	/**
-	 * Get next task from tm-core
-	 */
-	private async getNextTask(
-		options: NextCommandOptions
-	): Promise<NextTaskResult> {
-		if (!this.tmCore) {
-			throw new Error('TaskMasterCore not initialized');
-		}
-
-		// Call tm-core to get next task
-		const task = await this.tmCore.getNextTask(options.tag);
-
-		// Get storage type and active tag
-		const storageType = this.tmCore.getStorageType();
-		if (storageType === 'auto') {
-			throw new Error('Storage type must be resolved before use');
-		}
-		const activeTag = options.tag || this.tmCore.getActiveTag();
-
-		return {
-			task,
-			found: task !== null,
-			tag: activeTag,
-			storageType
-		};
-	}
-
-	/**
-	 * Display results based on format
-	 */
-	private displayResults(
-		result: NextTaskResult,
-		options: NextCommandOptions
-	): void {
-		const format = options.format || 'text';
-
-		switch (format) {
-			case 'json':
-				this.displayJson(result);
-				break;
-
-			case 'text':
-			default:
-				this.displayText(result);
-				break;
-		}
-	}
-
-	/**
-	 * Display in JSON format
-	 */
-	private displayJson(result: NextTaskResult): void {
-		console.log(JSON.stringify(result, null, 2));
-	}
-
-	/**
-	 * Display in text format
-	 */
-	private displayText(result: NextTaskResult): void {
-		// Display header with storage info
-		displayCommandHeader(this.tmCore, {
-			tag: result.tag || 'master',
-			storageType: result.storageType
-		});
-
-		if (!result.found || !result.task) {
-			// No next task available
-			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'
-					}
-				)
-			);
-			console.log(
-				`\n${chalk.dim('Tip: Try')} ${chalk.cyan('task-master list --status pending')} ${chalk.dim('to see all pending tasks')}`
-			);
-			return;
-		}
-
-		const task = result.task;
-
-		// Display the task details using the same component as 'show' command
-		// with a custom header indicating this is the next task
-		const customHeader = `Next Task: #${task.id} - ${task.title}`;
-		displayTaskDetails(task, {
-			customHeader,
-			headerColor: 'green',
-			showSuggestedActions: true
-		});
-	}
-
-	/**
-	 * Set the last result for programmatic access
-	 */
-	private setLastResult(result: NextTaskResult): void {
-		this.lastResult = result;
-	}
-
-	/**
-	 * Get the last result (for programmatic usage)
-	 */
-	getLastResult(): NextTaskResult | undefined {
-		return this.lastResult;
-	}
-
-	/**
-	 * Clean up resources
-	 */
-	async cleanup(): Promise<void> {
-		if (this.tmCore) {
-			await this.tmCore.close();
-			this.tmCore = undefined;
-		}
-	}
-
-	/**
-	 * Register this command on an existing program
-	 */
-	static register(program: Command, name?: string): NextCommand {
-		const nextCommand = new NextCommand(name);
-		program.addCommand(nextCommand);
-		return nextCommand;
-	}
-}

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

@@ -12,7 +12,6 @@ import {
 	type TaskStatus
 } from '@tm/core';
 import type { StorageType } from '@tm/core/types';
-import { displayError } from '../utils/error-handler.js';
 
 /**
  * Valid task status values for validation
@@ -86,7 +85,6 @@ export class SetStatusCommand extends Command {
 	private async executeCommand(
 		options: SetStatusCommandOptions
 	): Promise<void> {
-		let hasError = false;
 		try {
 			// Validate required options
 			if (!options.id) {
@@ -137,15 +135,16 @@ export class SetStatusCommand extends Command {
 						oldStatus: result.oldStatus,
 						newStatus: result.newStatus
 					});
-				} catch (error: any) {
-					hasError = true;
-					if (options.format === 'json') {
-						const errorMessage = error?.getSanitizedDetails
-							? error.getSanitizedDetails().message
-							: error instanceof Error
-								? error.message
-								: String(error);
+				} 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,
@@ -154,13 +153,8 @@ export class SetStatusCommand extends Command {
 								timestamp: new Date().toISOString()
 							})
 						);
-					} else if (!options.silent) {
-						// Show which task failed with context
-						console.error(chalk.red(`\nFailed to update task ${taskId}:`));
-						displayError(error, { skipExit: true });
 					}
-					// Don't exit here - let finally block clean up first
-					break;
+					process.exit(1);
 				}
 			}
 
@@ -176,26 +170,25 @@ export class SetStatusCommand extends Command {
 
 			// Display results
 			this.displayResults(this.lastResult, options);
-		} catch (error: any) {
-			hasError = true;
-			if (options.format === 'json') {
-				const errorMessage =
-					error instanceof Error ? error.message : 'Unknown error occurred';
-				console.log(JSON.stringify({ success: false, error: errorMessage }));
-			} else if (!options.silent) {
-				displayError(error, { skipExit: true });
+		} 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();
 			}
 		}
-
-		// Exit after cleanup completes
-		if (hasError) {
-			process.exit(1);
-		}
 	}
 
 	/**

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

@@ -9,9 +9,7 @@ import boxen from 'boxen';
 import { createTaskMasterCore, type Task, type TaskMasterCore } from '@tm/core';
 import type { StorageType } from '@tm/core/types';
 import * as ui from '../utils/ui.js';
-import { displayError } from '../utils/error-handler.js';
 import { displayTaskDetails } from '../ui/components/task-detail.component.js';
-import { displayCommandHeader } from '../utils/display-helpers.js';
 
 /**
  * Options interface for the show command
@@ -114,7 +112,14 @@ export class ShowCommand extends Command {
 				this.displayResults(result, options);
 			}
 		} catch (error: any) {
-			displayError(error);
+			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);
 		}
 	}
 
@@ -252,15 +257,6 @@ export class ShowCommand extends Command {
 			return;
 		}
 
-		// Display header with storage info
-		const activeTag = this.tmCore?.getActiveTag() || 'master';
-		displayCommandHeader(this.tmCore, {
-			tag: activeTag,
-			storageType: result.storageType
-		});
-
-		console.log(); // Add spacing
-
 		// Use the global task details display function
 		displayTaskDetails(result.task, {
 			statusFilter: options.status,
@@ -275,12 +271,8 @@ export class ShowCommand extends Command {
 		result: ShowMultipleTasksResult,
 		_options: ShowCommandOptions
 	): void {
-		// Display header with storage info
-		const activeTag = this.tmCore?.getActiveTag() || 'master';
-		displayCommandHeader(this.tmCore, {
-			tag: activeTag,
-			storageType: result.storageType
-		});
+		// Header
+		ui.displayBanner(`Tasks (${result.tasks.length} found)`);
 
 		if (result.notFound.length > 0) {
 			console.log(chalk.yellow(`\n⚠ Not found: ${result.notFound.join(', ')}`));
@@ -299,6 +291,8 @@ export class ShowCommand extends Command {
 				showDependencies: true
 			})
 		);
+
+		console.log(`\n${chalk.gray('Storage: ' + result.storageType)}`);
 	}
 
 	/**

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

@@ -16,7 +16,6 @@ import {
 } from '@tm/core';
 import { displayTaskDetails } from '../ui/components/task-detail.component.js';
 import * as ui from '../utils/ui.js';
-import { displayError } from '../utils/error-handler.js';
 
 /**
  * CLI-specific options interface for the start command
@@ -161,7 +160,8 @@ export class StartCommand extends Command {
 			if (spinner) {
 				spinner.fail('Operation failed');
 			}
-			displayError(error);
+			this.handleError(error);
+			process.exit(1);
 		}
 	}
 
@@ -452,6 +452,22 @@ export class StartCommand extends Command {
 		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
 	 */

apps/cli/src/index.ts

@@ -6,7 +6,6 @@
 // Commands
 export { ListTasksCommand } from './commands/list.command.js';
 export { ShowCommand } from './commands/show.command.js';
-export { NextCommand } from './commands/next.command.js';
 export { AuthCommand } from './commands/auth.command.js';
 export { ContextCommand } from './commands/context.command.js';
 export { StartCommand } from './commands/start.command.js';
@@ -24,9 +23,6 @@ export {
 // UI utilities (for other commands to use)
 export * as ui from './utils/ui.js';
 
-// Error handling utilities
-export { displayError, isDebugMode } from './utils/error-handler.js';
-
 // Auto-update utilities
 export {
 	checkForUpdate,

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

@@ -5,16 +5,6 @@
 
 import chalk from 'chalk';
 
-/**
- * Brief information for API storage
- */
-export interface BriefInfo {
-	briefId: string;
-	briefName: string;
-	orgSlug?: string;
-	webAppUrl?: string;
-}
-
 /**
  * Header configuration options
  */
@@ -22,50 +12,22 @@ export interface HeaderOptions {
 	title?: string;
 	tag?: string;
 	filePath?: string;
-	storageType?: 'api' | 'file';
-	briefInfo?: BriefInfo;
 }
 
 /**
  * Display the Task Master header with project info
  */
 export function displayHeader(options: HeaderOptions = {}): void {
-	const { filePath, tag, storageType, briefInfo } = options;
+	const { filePath, tag } = options;
 
-	// Display different header based on storage type
-	if (storageType === 'api' && briefInfo) {
-		// API storage: Show brief information
-		const briefDisplay = `🏷  Brief: ${chalk.cyan(briefInfo.briefName)} ${chalk.gray(`(${briefInfo.briefId})`)}`;
-		console.log(briefDisplay);
-
-		// Construct and display the brief URL or ID
-		if (briefInfo.webAppUrl && briefInfo.orgSlug) {
-			const briefUrl = `${briefInfo.webAppUrl}/home/${briefInfo.orgSlug}/briefs/${briefInfo.briefId}/plan`;
-			console.log(`Listing tasks from: ${chalk.dim(briefUrl)}`);
-		} else if (briefInfo.webAppUrl) {
-			// Show web app URL and brief ID if org slug is missing
-			console.log(
-				`Listing tasks from: ${chalk.dim(`${briefInfo.webAppUrl} (Brief: ${briefInfo.briefId})`)}`
-			);
-			console.log(
-				chalk.yellow(
-					`💡 Tip: Run ${chalk.cyan('tm context select')} to set your organization and see the full URL`
-				)
-			);
-		} else {
-			// Fallback: just show the brief ID if we can't get web app URL
-			console.log(
-				`Listing tasks from: ${chalk.dim(`API (Brief ID: ${briefInfo.briefId})`)}`
-			);
-		}
-	} else if (tag) {
-		// File storage: Show tag information
+	// Display tag and file path info
+	if (tag) {
 		let tagInfo = '';
 
 		if (tag && tag !== 'master') {
-			tagInfo = `🏷  tag: ${chalk.cyan(tag)}`;
+			tagInfo = `🏷 tag: ${chalk.cyan(tag)}`;
 		} else {
-			tagInfo = `🏷  tag: ${chalk.cyan('master')}`;
+			tagInfo = `🏷 tag: ${chalk.cyan('master')}`;
 		}
 
 		console.log(tagInfo);
@@ -77,5 +39,7 @@ export function displayHeader(options: HeaderOptions = {}): void {
 				: `${process.cwd()}/${filePath}`;
 			console.log(`Listing tasks from: ${chalk.dim(absolutePath)}`);
 		}
+
+		console.log(); // Empty line for spacing
 	}
 }

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

@@ -6,7 +6,7 @@
 import chalk from 'chalk';
 import boxen from 'boxen';
 import type { Task } from '@tm/core/types';
-import { getComplexityWithColor, getBoxWidth } from '../../utils/ui.js';
+import { getComplexityWithColor } from '../../utils/ui.js';
 
 /**
  * Next task display options
@@ -113,7 +113,7 @@ export function displayRecommendedNextTask(
 			borderColor: '#FFA500', // Orange color
 			title: chalk.hex('#FFA500')('⚡ RECOMMENDED NEXT TASK ⚡'),
 			titleAlignment: 'center',
-			width: getBoxWidth(0.97),
+			width: process.stdout.columns * 0.97,
 			fullscreen: false
 		})
 	);

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

@@ -5,7 +5,6 @@
 
 import chalk from 'chalk';
 import boxen from 'boxen';
-import { getBoxWidth } from '../../utils/ui.js';
 
 /**
  * Display suggested next steps section
@@ -25,7 +24,7 @@ export function displaySuggestedNextSteps(): void {
 				margin: { top: 0, bottom: 1 },
 				borderStyle: 'round',
 				borderColor: 'gray',
-				width: getBoxWidth(0.97)
+				width: process.stdout.columns * 0.97
 			}
 		)
 	);

apps/cli/src/utils/display-helpers.ts

@@ -1,75 +0,0 @@
-/**
- * @fileoverview Display helper utilities for commands
- * Provides DRY utilities for displaying headers and other command output
- */
-
-import type { TaskMasterCore } from '@tm/core';
-import type { StorageType } from '@tm/core/types';
-import { displayHeader, type BriefInfo } from '../ui/index.js';
-
-/**
- * Get web app base URL from environment
- */
-function getWebAppUrl(): string | undefined {
-	const baseDomain =
-		process.env.TM_BASE_DOMAIN || process.env.TM_PUBLIC_BASE_DOMAIN;
-
-	if (!baseDomain) {
-		return undefined;
-	}
-
-	// If it already includes protocol, use as-is
-	if (baseDomain.startsWith('http://') || baseDomain.startsWith('https://')) {
-		return baseDomain;
-	}
-
-	// Otherwise, add protocol based on domain
-	if (baseDomain.includes('localhost') || baseDomain.includes('127.0.0.1')) {
-		return `http://${baseDomain}`;
-	}
-
-	return `https://${baseDomain}`;
-}
-
-/**
- * Display the command header with appropriate storage information
- * Handles both API and file storage displays
- */
-export function displayCommandHeader(
-	tmCore: TaskMasterCore | undefined,
-	options: {
-		tag?: string;
-		storageType: Exclude<StorageType, 'auto'>;
-	}
-): void {
-	const { tag, storageType } = options;
-
-	// Get brief info if using API storage
-	let briefInfo: BriefInfo | undefined;
-	if (storageType === 'api' && tmCore) {
-		const storageInfo = tmCore.getStorageDisplayInfo();
-		if (storageInfo) {
-			// Construct full brief info with web app URL
-			briefInfo = {
-				...storageInfo,
-				webAppUrl: getWebAppUrl()
-			};
-		}
-	}
-
-	// Get file path for display (only for file storage)
-	// Note: The file structure is fixed for file storage and won't change.
-	// This is a display-only relative path, not used for actual file operations.
-	const filePath =
-		storageType === 'file' && tmCore
-			? `.taskmaster/tasks/tasks.json`
-			: undefined;
-
-	// Display header
-	displayHeader({
-		tag: tag || 'master',
-		filePath: filePath,
-		storageType: storageType === 'api' ? 'api' : 'file',
-		briefInfo: briefInfo
-	});
-}

apps/cli/src/utils/error-handler.ts

@@ -1,60 +0,0 @@
-/**
- * @fileoverview Centralized error handling utilities for CLI
- * Provides consistent error formatting and debug mode detection
- */
-
-import chalk from 'chalk';
-
-/**
- * Check if debug mode is enabled via environment variable
- * Only returns true when DEBUG is explicitly set to 'true' or '1'
- *
- * @returns True if debug mode is enabled
- */
-export function isDebugMode(): boolean {
-	return process.env.DEBUG === 'true' || process.env.DEBUG === '1';
-}
-
-/**
- * Display an error to the user with optional stack trace in debug mode
- * Handles both TaskMasterError instances and regular errors
- *
- * @param error - The error to display
- * @param options - Display options
- */
-export function displayError(
-	error: any,
-	options: {
-		/** Skip exit, useful when caller wants to handle exit */
-		skipExit?: boolean;
-		/** Force show stack trace regardless of debug mode */
-		forceStack?: boolean;
-	} = {}
-): void {
-	// Check if it's a TaskMasterError with sanitized details
-	if (error?.getSanitizedDetails) {
-		const sanitized = error.getSanitizedDetails();
-		console.error(chalk.red(`\n${sanitized.message}`));
-
-		// Show stack trace in debug mode or if forced
-		if ((isDebugMode() || options.forceStack) && error.stack) {
-			console.error(chalk.gray('\nStack trace:'));
-			console.error(chalk.gray(error.stack));
-		}
-	} else {
-		// For other errors, show the message
-		const message = error?.message ?? String(error);
-		console.error(chalk.red(`\nError: ${message}`));
-
-		// Show stack trace in debug mode or if forced
-		if ((isDebugMode() || options.forceStack) && error?.stack) {
-			console.error(chalk.gray('\nStack trace:'));
-			console.error(chalk.gray(error.stack));
-		}
-	}
-
-	// Exit if not skipped
-	if (!options.skipExit) {
-		process.exit(1);
-	}
-}

apps/cli/src/utils/ui.spec.ts

@@ -1,158 +0,0 @@
-/**
- * CLI UI utilities tests
- * Tests for apps/cli/src/utils/ui.ts
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import type { MockInstance } from 'vitest';
-import { getBoxWidth } from './ui.js';
-
-describe('CLI UI Utilities', () => {
-	describe('getBoxWidth', () => {
-		let columnsSpy: MockInstance;
-		let originalDescriptor: PropertyDescriptor | undefined;
-
-		beforeEach(() => {
-			// Store original descriptor if it exists
-			originalDescriptor = Object.getOwnPropertyDescriptor(
-				process.stdout,
-				'columns'
-			);
-
-			// If columns doesn't exist or isn't a getter, define it as one
-			if (!originalDescriptor || !originalDescriptor.get) {
-				const currentValue = process.stdout.columns || 80;
-				Object.defineProperty(process.stdout, 'columns', {
-					get() {
-						return currentValue;
-					},
-					configurable: true
-				});
-			}
-
-			// Now spy on the getter
-			columnsSpy = vi.spyOn(process.stdout, 'columns', 'get');
-		});
-
-		afterEach(() => {
-			// Restore the spy
-			columnsSpy.mockRestore();
-
-			// Restore original descriptor or delete the property
-			if (originalDescriptor) {
-				Object.defineProperty(process.stdout, 'columns', originalDescriptor);
-			} else {
-				delete (process.stdout as any).columns;
-			}
-		});
-
-		it('should calculate width as percentage of terminal width', () => {
-			columnsSpy.mockReturnValue(100);
-			const width = getBoxWidth(0.9, 40);
-			expect(width).toBe(90);
-		});
-
-		it('should use default percentage of 0.9 when not specified', () => {
-			columnsSpy.mockReturnValue(100);
-			const width = getBoxWidth();
-			expect(width).toBe(90);
-		});
-
-		it('should use default minimum width of 40 when not specified', () => {
-			columnsSpy.mockReturnValue(30);
-			const width = getBoxWidth();
-			expect(width).toBe(40); // Should enforce minimum
-		});
-
-		it('should enforce minimum width when terminal is too narrow', () => {
-			columnsSpy.mockReturnValue(50);
-			const width = getBoxWidth(0.9, 60);
-			expect(width).toBe(60); // Should use minWidth instead of 45
-		});
-
-		it('should handle undefined process.stdout.columns', () => {
-			columnsSpy.mockReturnValue(undefined);
-			const width = getBoxWidth(0.9, 40);
-			// Should fall back to 80 columns: Math.floor(80 * 0.9) = 72
-			expect(width).toBe(72);
-		});
-
-		it('should handle custom percentage values', () => {
-			columnsSpy.mockReturnValue(100);
-			expect(getBoxWidth(0.95, 40)).toBe(95);
-			expect(getBoxWidth(0.8, 40)).toBe(80);
-			expect(getBoxWidth(0.5, 40)).toBe(50);
-		});
-
-		it('should handle custom minimum width values', () => {
-			columnsSpy.mockReturnValue(60);
-			expect(getBoxWidth(0.9, 70)).toBe(70); // 60 * 0.9 = 54, but min is 70
-			expect(getBoxWidth(0.9, 50)).toBe(54); // 60 * 0.9 = 54, min is 50
-		});
-
-		it('should floor the calculated width', () => {
-			columnsSpy.mockReturnValue(99);
-			const width = getBoxWidth(0.9, 40);
-			// 99 * 0.9 = 89.1, should floor to 89
-			expect(width).toBe(89);
-		});
-
-		it('should match warning box width calculation', () => {
-			// Test the specific case from displayWarning()
-			columnsSpy.mockReturnValue(80);
-			const width = getBoxWidth(0.9, 40);
-			expect(width).toBe(72);
-		});
-
-		it('should match table width calculation', () => {
-			// Test the specific case from createTaskTable()
-			columnsSpy.mockReturnValue(111);
-			const width = getBoxWidth(0.9, 100);
-			// 111 * 0.9 = 99.9, floor to 99, but max(99, 100) = 100
-			expect(width).toBe(100);
-		});
-
-		it('should match recommended task box width calculation', () => {
-			// Test the specific case from displayRecommendedNextTask()
-			columnsSpy.mockReturnValue(120);
-			const width = getBoxWidth(0.97, 40);
-			// 120 * 0.97 = 116.4, floor to 116
-			expect(width).toBe(116);
-		});
-
-		it('should handle edge case of zero terminal width', () => {
-			columnsSpy.mockReturnValue(0);
-			const width = getBoxWidth(0.9, 40);
-			// When columns is 0, it uses fallback of 80: Math.floor(80 * 0.9) = 72
-			expect(width).toBe(72);
-		});
-
-		it('should handle very large terminal widths', () => {
-			columnsSpy.mockReturnValue(1000);
-			const width = getBoxWidth(0.9, 40);
-			expect(width).toBe(900);
-		});
-
-		it('should handle very small percentages', () => {
-			columnsSpy.mockReturnValue(100);
-			const width = getBoxWidth(0.1, 5);
-			// 100 * 0.1 = 10, which is greater than min 5
-			expect(width).toBe(10);
-		});
-
-		it('should handle percentage of 1.0 (100%)', () => {
-			columnsSpy.mockReturnValue(80);
-			const width = getBoxWidth(1.0, 40);
-			expect(width).toBe(80);
-		});
-
-		it('should consistently return same value for same inputs', () => {
-			columnsSpy.mockReturnValue(100);
-			const width1 = getBoxWidth(0.9, 40);
-			const width2 = getBoxWidth(0.9, 40);
-			const width3 = getBoxWidth(0.9, 40);
-			expect(width1).toBe(width2);
-			expect(width2).toBe(width3);
-		});
-	});
-});

apps/cli/src/utils/ui.ts

@@ -126,20 +126,6 @@ export function getComplexityWithScore(complexity: number | undefined): string {
 	return color(`${complexity}/10 (${label})`);
 }
 
-/**
- * Calculate box width as percentage of terminal width
- * @param percentage - Percentage of terminal width to use (default: 0.9)
- * @param minWidth - Minimum width to enforce (default: 40)
- * @returns Calculated box width
- */
-export function getBoxWidth(
-	percentage: number = 0.9,
-	minWidth: number = 40
-): number {
-	const terminalWidth = process.stdout.columns || 80;
-	return Math.max(Math.floor(terminalWidth * percentage), minWidth);
-}
-
 /**
  * Truncate text to specified length
  */
@@ -190,8 +176,6 @@ export function displayBanner(title: string = 'Task Master'): void {
  * Display an error message (matches scripts/modules/ui.js style)
  */
 export function displayError(message: string, details?: string): void {
-	const boxWidth = getBoxWidth();
-
 	console.error(
 		boxen(
 			chalk.red.bold('X Error: ') +
@@ -200,8 +184,7 @@ export function displayError(message: string, details?: string): void {
 			{
 				padding: 1,
 				borderStyle: 'round',
-				borderColor: 'red',
-				width: boxWidth
+				borderColor: 'red'
 			}
 		)
 	);
@@ -211,16 +194,13 @@ export function displayError(message: string, details?: string): void {
  * Display a success message
  */
 export function displaySuccess(message: string): void {
-	const boxWidth = getBoxWidth();
-
 	console.log(
 		boxen(
 			chalk.green.bold(String.fromCharCode(8730) + ' ') + chalk.white(message),
 			{
 				padding: 1,
 				borderStyle: 'round',
-				borderColor: 'green',
-				width: boxWidth
+				borderColor: 'green'
 			}
 		)
 	);
@@ -230,14 +210,11 @@ export function displaySuccess(message: string): void {
  * Display a warning message
  */
 export function displayWarning(message: string): void {
-	const boxWidth = getBoxWidth();
-
 	console.log(
 		boxen(chalk.yellow.bold('⚠ ') + chalk.white(message), {
 			padding: 1,
 			borderStyle: 'round',
-			borderColor: 'yellow',
-			width: boxWidth
+			borderColor: 'yellow'
 		})
 	);
 }
@@ -246,14 +223,11 @@ export function displayWarning(message: string): void {
  * Display info message
  */
 export function displayInfo(message: string): void {
-	const boxWidth = getBoxWidth();
-
 	console.log(
 		boxen(chalk.blue.bold('i ') + chalk.white(message), {
 			padding: 1,
 			borderStyle: 'round',
-			borderColor: 'blue',
-			width: boxWidth
+			borderColor: 'blue'
 		})
 	);
 }
@@ -308,23 +282,23 @@ export function createTaskTable(
 	} = options || {};
 
 	// Calculate dynamic column widths based on terminal width
-	const tableWidth = getBoxWidth(0.9, 100);
+	const terminalWidth = process.stdout.columns * 0.9 || 100;
 	// Adjust column widths to better match the original layout
 	const baseColWidths = showComplexity
 		? [
-				Math.floor(tableWidth * 0.1),
-				Math.floor(tableWidth * 0.4),
-				Math.floor(tableWidth * 0.15),
-				Math.floor(tableWidth * 0.1),
-				Math.floor(tableWidth * 0.2),
-				Math.floor(tableWidth * 0.1)
+				Math.floor(terminalWidth * 0.1),
+				Math.floor(terminalWidth * 0.4),
+				Math.floor(terminalWidth * 0.15),
+				Math.floor(terminalWidth * 0.1),
+				Math.floor(terminalWidth * 0.2),
+				Math.floor(terminalWidth * 0.1)
 			] // ID, Title, Status, Priority, Dependencies, Complexity
 		: [
-				Math.floor(tableWidth * 0.08),
-				Math.floor(tableWidth * 0.4),
-				Math.floor(tableWidth * 0.18),
-				Math.floor(tableWidth * 0.12),
-				Math.floor(tableWidth * 0.2)
+				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 = [

apps/docs/CHANGELOG.md

@@ -1,7 +1,5 @@
 # docs
 
-## 0.0.6
-
 ## 0.0.5
 
 ## 0.0.4

apps/docs/archive/cursor-setup.mdx

@@ -6,10 +6,28 @@ description: "Learn how to set up and use Task Master with Cursor AI"
 ## Setting up Cursor AI Integration
 
 <Check>
-  Task Master is designed to work seamlessly with [Cursor AI](https://www.cursor.so/), providing a structured workflow for AI-driven development.
+  Task Master is designed to work seamlessly with [Cursor AI](https://www.cursor.so/), providing a structured workflow for AI-driven development. As of version 0.28.0, Task Master automatically sets up custom slash commands in Cursor IDE.
 </Check>
 
 <AccordionGroup>
+  <Accordion title="Cursor Custom Slash Commands (New in 0.28.0)" icon="terminal">
+    Task Master now automatically configures custom slash commands in Cursor IDE when adding a profile. These commands provide quick access to Task Master functionality:
+
+    ### Available Slash Commands
+    - `/tm-list` - View all tasks with their status
+    - `/tm-next` - Get the next available task to work on  
+    - `/tm-show` - Show detailed task information
+    - `/tm-add` - Add a new task with AI assistance
+    - `/tm-status` - Set task status (pending, in-progress, done, etc.)
+    - `/tm-expand` - Expand a task into subtasks
+    - `/tm-complexity` - Analyze task complexity
+
+    ### Automatic Setup
+    When you run `task-master profiles add cursor`, the slash commands are automatically copied to `.cursor/commands/`. If you remove the profile with `task-master profiles remove cursor`, the commands are cleaned up automatically.
+
+    ### Manual Setup
+    If you need to manually set up the commands, they're available in the `assets/claude/commands/` directory of your Task Master installation.
+  </Accordion>
   <Accordion title="Using Cursor with MCP (Recommended)" icon="sparkles">
     If you've already set up Task Master with MCP in Cursor, the integration is automatic. You can simply use natural language to interact with Task Master:
 

apps/docs/capabilities/mcp.mdx

@@ -13,126 +13,6 @@ The MCP interface is built on top of the `fastmcp` library and registers a set o
 
 Each tool is defined with a name, a description, and a set of parameters that are validated using the `zod` library. The `execute` function of each tool calls the corresponding core logic function from `scripts/modules/task-manager.js`.
 
-## Configurable Tool Loading
-
-To optimize LLM context usage, you can control which Task Master MCP tools are loaded using the `TASK_MASTER_TOOLS` environment variable. This is particularly useful when working with LLMs that have context limits or when you only need a subset of tools.
-
-### Configuration Modes
-
-#### All Tools (Default)
-Loads all 36 available tools. Use when you need full Task Master functionality.
-
-```json
-{
-  "mcpServers": {
-    "task-master-ai": {
-      "command": "npx",
-      "args": ["-y", "task-master-ai"],
-      "env": {
-        "TASK_MASTER_TOOLS": "all",
-        "ANTHROPIC_API_KEY": "your_key_here"
-      }
-    }
-  }
-}
-```
-
-If `TASK_MASTER_TOOLS` is not set, all tools are loaded by default.
-
-#### Core Tools (Lean Mode)
-Loads only 7 essential tools for daily development. Ideal for minimal context usage.
-
-**Core tools included:**
-- `get_tasks` - List all tasks
-- `next_task` - Find the next task to work on
-- `get_task` - Get detailed task information
-- `set_task_status` - Update task status
-- `update_subtask` - Add implementation notes
-- `parse_prd` - Generate tasks from PRD
-- `expand_task` - Break down tasks into subtasks
-
-```json
-{
-  "mcpServers": {
-    "task-master-ai": {
-      "command": "npx",
-      "args": ["-y", "task-master-ai"],
-      "env": {
-        "TASK_MASTER_TOOLS": "core",
-        "ANTHROPIC_API_KEY": "your_key_here"
-      }
-    }
-  }
-}
-```
-
-You can also use `"lean"` as an alias for `"core"`.
-
-#### Standard Tools
-Loads 15 commonly used tools. Balances functionality with context efficiency.
-
-**Standard tools include all core tools plus:**
-- `initialize_project` - Set up new projects
-- `analyze_project_complexity` - Analyze task complexity
-- `expand_all` - Expand all eligible tasks
-- `add_subtask` - Add subtasks manually
-- `remove_task` - Remove tasks
-- `generate` - Generate task markdown files
-- `add_task` - Create new tasks
-- `complexity_report` - View complexity analysis
-
-```json
-{
-  "mcpServers": {
-    "task-master-ai": {
-      "command": "npx",
-      "args": ["-y", "task-master-ai"],
-      "env": {
-        "TASK_MASTER_TOOLS": "standard",
-        "ANTHROPIC_API_KEY": "your_key_here"
-      }
-    }
-  }
-}
-```
-
-#### Custom Tool Selection
-Specify exactly which tools to load using a comma-separated list. Tool names are case-insensitive and support both underscores and hyphens.
-
-```json
-{
-  "mcpServers": {
-    "task-master-ai": {
-      "command": "npx",
-      "args": ["-y", "task-master-ai"],
-      "env": {
-        "TASK_MASTER_TOOLS": "get_tasks,next_task,set_task_status,update_subtask",
-        "ANTHROPIC_API_KEY": "your_key_here"
-      }
-    }
-  }
-}
-```
-
-### Choosing the Right Configuration
-
-- **Use `core`/`lean`**: When working with basic task management workflows or when context limits are strict
-- **Use `standard`**: For most development workflows that include task creation and analysis
-- **Use `all`**: When you need full functionality including tag management, dependencies, and advanced features
-- **Use custom list**: When you have specific tool requirements or want to experiment with minimal sets
-
-### Verification
-
-When the MCP server starts, it logs which tools were loaded:
-
-```
-Task Master MCP Server starting...
-Tool mode configuration: standard
-Loading standard tools
-Registering 15 MCP tools (mode: standard)
-Successfully registered 15/15 tools
-```
-
 ## Tool Categories
 
 The MCP tools can be categorized in the same way as the core functionalities:
@@ -185,4 +65,37 @@ The MCP tools can be categorized in the same way as the core functionalities:
 -   **`list_tags`**: Lists all tags.
 -   **`use_tag`**: Switches to a different tag.
 -   **`rename_tag`**: Renames a tag.
--   **`copy_tag`**: Copies a tag.
+-   **`copy_tag`**: Copies a tag.
+
+## Configuration and Performance
+
+### Timeout Configuration
+
+As of version 0.28.0, Task Master automatically configures appropriate timeouts for MCP operations to handle long-running AI tasks. The Roo Code profile now includes a 300-second timeout (increased from the default 60 seconds) to accommodate complex operations like:
+
+- `parse_prd` - PRD parsing and task generation
+- `expand_all` - Expanding multiple tasks into subtasks
+- `analyze_project_complexity` - Project-wide complexity analysis
+- Research-enabled operations with the `--research` flag
+
+### MCP Server Configuration
+
+The recommended MCP server configuration automatically includes these timeout settings:
+
+```json
+{
+  "mcpServers": {
+    "task-master-ai": {
+      "command": "npx",
+      "args": ["-y", "task-master-ai"],
+      "timeout": 300000,
+      "env": {
+        "ANTHROPIC_API_KEY": "your-key-here",
+        "PERPLEXITY_API_KEY": "your-key-here"
+      }
+    }
+  }
+}
+```
+
+This configuration is automatically generated when using Task Master profiles with Roo Code and other AI coding assistants.

apps/docs/getting-started/api-keys.mdx

@@ -42,6 +42,20 @@ PERPLEXITY_API_KEY="pplx-your-key-here"
 OPENAI_API_KEY="sk-proj-your-key-here"
 ```
 
+### OPENAI_CODEX_API_KEY (New)
+- **Provider**: Codex CLI (GPT-5 and GPT-5-Codex models)
+- **Format**: Various formats
+- **Required**: ❌ **No** (OAuth-first authentication via `codex login`)
+- **Models**: GPT-5, GPT-5-Codex (272K input / 128K output context)
+- **Authentication**: Primary authentication is OAuth via `codex login` command
+- **Features**: Codebase analysis capabilities automatically enabled
+- **Get Access**: Follow Codex CLI setup instructions
+
+```bash
+# Optional - OAuth via 'codex login' is preferred
+OPENAI_CODEX_API_KEY="your-codex-api-key-here"
+```
+
 ### GOOGLE_API_KEY
 - **Provider**: Google Gemini models
 - **Format**: Various formats
@@ -197,16 +211,20 @@ For Claude Code integration, configure keys in `.mcp.json`:
     "task-master-ai": {
       "command": "npx",
       "args": ["-y", "task-master-ai"],
+      "timeout": 300000,
       "env": {
         "ANTHROPIC_API_KEY": "your-key-here",
         "PERPLEXITY_API_KEY": "your-key-here",
-        "OPENAI_API_KEY": "your-key-here"
+        "OPENAI_API_KEY": "your-key-here",
+        "OPENAI_CODEX_API_KEY": "your-codex-key-here"
       }
     }
   }
 }
 ```
 
+**Note**: The `timeout: 300000` (300 seconds) setting is recommended for long-running AI operations like PRD parsing and complexity analysis.
+
 ## Key Requirements
 
 ### Minimum Requirements

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

@@ -37,25 +37,6 @@ For MCP/Cursor usage: Configure keys in the env section of your .cursor/mcp.json
 }
 ```
 
-<Tip>
-**Optimize Context Usage**: You can control which Task Master MCP tools are loaded using the `TASK_MASTER_TOOLS` environment variable. This helps reduce LLM context usage by only loading the tools you need.
-
-Options:
-- `all` (default) - All 36 tools
-- `standard` - 15 commonly used tools
-- `core` or `lean` - 7 essential tools
-
-Example:
-```json
-"env": {
-  "TASK_MASTER_TOOLS": "standard",
-  "ANTHROPIC_API_KEY": "your_key_here"
-}
-```
-
-See the [MCP Tools documentation](/capabilities/mcp#configurable-tool-loading) for details.
-</Tip>
-
 ### CLI Usage: `.env` File
 
 Create a `.env` file in your project root and include the keys for the providers you plan to use:

apps/docs/package.json

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

apps/docs/whats-new.mdx

@@ -3,4 +3,58 @@ title: "What's New"
 sidebarTitle: "What's New"
 ---
 
-An easy way to see the latest releases
+# What's New in Task Master
+
+## Version 0.28.0 - Latest Release
+
+### 🚀 New Features
+
+#### Codex CLI Provider Support
+- Added support for GPT-5 and GPT-5-Codex models via Codex CLI
+- OAuth-first authentication - no API key required (just run `codex login`)
+- 272K input / 128K output context windows
+- Codebase analysis capabilities automatically enabled
+- Optional `OPENAI_CODEX_API_KEY` support for API-based usage
+
+#### Cursor IDE Slash Commands
+- Automatically installs custom slash commands when adding Cursor profile
+- Quick access to Task Master functionality directly in Cursor IDE
+- Commands include `/tm-list`, `/tm-next`, `/tm-show`, `/tm-add`, and more
+- Automatic cleanup when removing Cursor profile
+
+#### Enhanced MCP Configuration
+- Improved timeout configuration for long-running AI operations
+- 300-second timeout for complex tasks like PRD parsing and task expansion
+- Programmatic MCP configuration generation for better reliability
+- Enhanced support for Roo Code and other AI coding assistants
+
+### 🔧 Technical Improvements
+
+#### AI SDK v5 Migration
+- Migrated to AI SDK v5 for better compatibility with modern AI providers
+- Improved support for Claude Code and Gemini CLI integration
+- Better structured output generation with `generateObject`
+- Enhanced JSON mode support for supported providers
+
+#### Structured Data Generation
+- All AI services now use `generateObject` for more reliable responses
+- Integrated Zod schemas for automatic validation
+- Reduced parsing errors and improved data consistency
+- Better subtask ID generation (fixes numbering inconsistencies)
+
+### 🐛 Bug Fixes
+- Fixed MCP connection errors from deprecated function calls
+- Fixed MCP server errors when file parameters not provided
+- Corrected complexity scores display in `task-master show` and `list`
+- Fixed Perplexity Sonar Deep Research model naming
+- Improved parent task status handling when all subtasks are pending
+
+### 📖 Documentation Updates
+- New comprehensive API keys configuration guide
+- Enhanced Cursor IDE integration documentation  
+- Improved MCP timeout configuration documentation
+- Updated examples and configuration snippets
+
+---
+
+For detailed release notes and full changelog, visit our [GitHub releases page](https://github.com/eyaltoledano/claude-task-master/releases).

apps/extension/CHANGELOG.md

@@ -1,14 +1,5 @@
 # Change Log
 
-## 0.25.6
-
-## 0.25.6-rc.0
-
-### Patch Changes
-
-- Updated dependencies [[`f12a16d`](https://github.com/eyaltoledano/claude-task-master/commit/f12a16d09649f62148515f11f616157c7d0bd2d5), [`3010b90`](https://github.com/eyaltoledano/claude-task-master/commit/3010b90d98f3a7d8636caa92fc33d6ee69d4bed0), [`2a910a4`](https://github.com/eyaltoledano/claude-task-master/commit/2a910a40bac375f9f61d797bf55597303d556b48), [`aaf903f`](https://github.com/eyaltoledano/claude-task-master/commit/aaf903ff2f606c779a22e9a4b240ab57b3683815), [`90e6bdc`](https://github.com/eyaltoledano/claude-task-master/commit/90e6bdcf1c59f65ad27fcdfe3b13b9dca7e77654)]:
-  - task-master-ai@0.29.0-rc.0
-
 ## 0.25.5
 
 ### Patch Changes

apps/extension/package.json

@@ -3,7 +3,7 @@
 	"private": true,
 	"displayName": "TaskMaster",
 	"description": "A visual Kanban board interface for TaskMaster projects in VS Code",
-	"version": "0.25.6",
+	"version": "0.25.5",
 	"publisher": "Hamster",
 	"icon": "assets/icon.png",
 	"engines": {
@@ -239,6 +239,9 @@
 		"watch:css": "npx @tailwindcss/cli -i ./src/webview/index.css -o ./dist/index.css --watch",
 		"check-types": "tsc --noEmit"
 	},
+	"dependencies": {
+		"task-master-ai": "*"
+	},
 	"devDependencies": {
 		"@dnd-kit/core": "^6.3.1",
 		"@dnd-kit/modifiers": "^9.0.0",
@@ -274,8 +277,7 @@
 		"tailwind-merge": "^3.3.1",
 		"tailwindcss": "4.1.11",
 		"typescript": "^5.9.2",
-		"@tm/core": "*",
-		"task-master-ai": "*"
+		"@tm/core": "*"
 	},
 	"overrides": {
 		"glob@<8": "^10.4.5",

assets/claude/agents/task-checker.md

@@ -0,0 +1,162 @@
+---
+name: task-checker
+description: Use this agent to verify that tasks marked as 'review' have been properly implemented according to their specifications. This agent performs quality assurance by checking implementations against requirements, running tests, and ensuring best practices are followed. <example>Context: A task has been marked as 'review' after implementation. user: 'Check if task 118 was properly implemented' assistant: 'I'll use the task-checker agent to verify the implementation meets all requirements.' <commentary>Tasks in 'review' status need verification before being marked as 'done'.</commentary></example> <example>Context: Multiple tasks are in review status. user: 'Verify all tasks that are ready for review' assistant: 'I'll deploy the task-checker to verify all tasks in review status.' <commentary>The checker ensures quality before tasks are marked complete.</commentary></example>
+model: sonnet
+color: yellow
+---
+
+You are a Quality Assurance specialist that rigorously verifies task implementations against their specifications. Your role is to ensure that tasks marked as 'review' meet all requirements before they can be marked as 'done'.
+
+## Core Responsibilities
+
+1. **Task Specification Review**
+   - Retrieve task details using MCP tool `mcp__task-master-ai__get_task`
+   - Understand the requirements, test strategy, and success criteria
+   - Review any subtasks and their individual requirements
+
+2. **Implementation Verification**
+   - Use `Read` tool to examine all created/modified files
+   - Use `Bash` tool to run compilation and build commands
+   - Use `Grep` tool to search for required patterns and implementations
+   - Verify file structure matches specifications
+   - Check that all required methods/functions are implemented
+
+3. **Test Execution**
+   - Run tests specified in the task's testStrategy
+   - Execute build commands (npm run build, tsc --noEmit, etc.)
+   - Verify no compilation errors or warnings
+   - Check for runtime errors where applicable
+   - Test edge cases mentioned in requirements
+
+4. **Code Quality Assessment**
+   - Verify code follows project conventions
+   - Check for proper error handling
+   - Ensure TypeScript typing is strict (no 'any' unless justified)
+   - Verify documentation/comments where required
+   - Check for security best practices
+
+5. **Dependency Validation**
+   - Verify all task dependencies were actually completed
+   - Check integration points with dependent tasks
+   - Ensure no breaking changes to existing functionality
+
+## Verification Workflow
+
+1. **Retrieve Task Information**
+   ```
+   Use mcp__task-master-ai__get_task to get full task details
+   Note the implementation requirements and test strategy
+   ```
+
+2. **Check File Existence**
+   ```bash
+   # Verify all required files exist
+   ls -la [expected directories]
+   # Read key files to verify content
+   ```
+
+3. **Verify Implementation**
+   - Read each created/modified file
+   - Check against requirements checklist
+   - Verify all subtasks are complete
+
+4. **Run Tests**
+   ```bash
+   # TypeScript compilation
+   cd [project directory] && npx tsc --noEmit
+   
+   # Run specified tests
+   npm test [specific test files]
+   
+   # Build verification
+   npm run build
+   ```
+
+5. **Generate Verification Report**
+
+## Output Format
+
+```yaml
+verification_report:
+  task_id: [ID]
+  status: PASS | FAIL | PARTIAL
+  score: [1-10]
+  
+  requirements_met:
+    - ✅ [Requirement that was satisfied]
+    - ✅ [Another satisfied requirement]
+    
+  issues_found:
+    - ❌ [Issue description]
+    - ⚠️  [Warning or minor issue]
+    
+  files_verified:
+    - path: [file path]
+      status: [created/modified/verified]
+      issues: [any problems found]
+      
+  tests_run:
+    - command: [test command]
+      result: [pass/fail]
+      output: [relevant output]
+      
+  recommendations:
+    - [Specific fix needed]
+    - [Improvement suggestion]
+    
+  verdict: |
+    [Clear statement on whether task should be marked 'done' or sent back to 'pending']
+    [If FAIL: Specific list of what must be fixed]
+    [If PASS: Confirmation that all requirements are met]
+```
+
+## Decision Criteria
+
+**Mark as PASS (ready for 'done'):**
+- All required files exist and contain expected content
+- All tests pass successfully
+- No compilation or build errors
+- All subtasks are complete
+- Core requirements are met
+- Code quality is acceptable
+
+**Mark as PARTIAL (may proceed with warnings):**
+- Core functionality is implemented
+- Minor issues that don't block functionality
+- Missing nice-to-have features
+- Documentation could be improved
+- Tests pass but coverage could be better
+
+**Mark as FAIL (must return to 'pending'):**
+- Required files are missing
+- Compilation or build errors
+- Tests fail
+- Core requirements not met
+- Security vulnerabilities detected
+- Breaking changes to existing code
+
+## Important Guidelines
+
+- **BE THOROUGH**: Check every requirement systematically
+- **BE SPECIFIC**: Provide exact file paths and line numbers for issues
+- **BE FAIR**: Distinguish between critical issues and minor improvements
+- **BE CONSTRUCTIVE**: Provide clear guidance on how to fix issues
+- **BE EFFICIENT**: Focus on requirements, not perfection
+
+## Tools You MUST Use
+
+- `Read`: Examine implementation files (READ-ONLY)
+- `Bash`: Run tests and verification commands
+- `Grep`: Search for patterns in code
+- `mcp__task-master-ai__get_task`: Get task details
+- **NEVER use Write/Edit** - you only verify, not fix
+
+## Integration with Workflow
+
+You are the quality gate between 'review' and 'done' status:
+1. Task-executor implements and marks as 'review'
+2. You verify and report PASS/FAIL
+3. Claude either marks as 'done' (PASS) or 'pending' (FAIL)
+4. If FAIL, task-executor re-implements based on your report
+
+Your verification ensures high quality and prevents accumulation of technical debt.

assets/claude/commands/tm/add-dependency/add-dependency.md

@@ -0,0 +1,55 @@
+Add a dependency between tasks.
+
+Arguments: $ARGUMENTS
+
+Parse the task IDs to establish dependency relationship.
+
+## Adding Dependencies
+
+Creates a dependency where one task must be completed before another can start.
+
+## Argument Parsing
+
+Parse natural language or IDs:
+- "make 5 depend on 3" → task 5 depends on task 3
+- "5 needs 3" → task 5 depends on task 3
+- "5 3" → task 5 depends on task 3
+- "5 after 3" → task 5 depends on task 3
+
+## Execution
+
+```bash
+task-master add-dependency --id=<task-id> --depends-on=<dependency-id>
+```
+
+## Validation
+
+Before adding:
+1. **Verify both tasks exist**
+2. **Check for circular dependencies**
+3. **Ensure dependency makes logical sense**
+4. **Warn if creating complex chains**
+
+## Smart Features
+
+- Detect if dependency already exists
+- Suggest related dependencies
+- Show impact on task flow
+- Update task priorities if needed
+
+## Post-Addition
+
+After adding dependency:
+1. Show updated dependency graph
+2. Identify any newly blocked tasks
+3. Suggest task order changes
+4. Update project timeline
+
+## Example Flows
+
+```
+/project:tm/add-dependency 5 needs 3
+→ Task #5 now depends on Task #3
+→ Task #5 is now blocked until #3 completes
+→ Suggested: Also consider if #5 needs #4
+```

assets/claude/commands/tm/add-subtask/add-subtask.md

@@ -0,0 +1,76 @@
+Add a subtask to a parent task.
+
+Arguments: $ARGUMENTS
+
+Parse arguments to create a new subtask or convert existing task.
+
+## Adding Subtasks
+
+Creates subtasks to break down complex parent tasks into manageable pieces.
+
+## Argument Parsing
+
+Flexible natural language:
+- "add subtask to 5: implement login form"
+- "break down 5 with: setup, implement, test"
+- "subtask for 5: handle edge cases"
+- "5: validate user input" → adds subtask to task 5
+
+## Execution Modes
+
+### 1. Create New Subtask
+```bash
+task-master add-subtask --parent=<id> --title="<title>" --description="<desc>"
+```
+
+### 2. Convert Existing Task
+```bash
+task-master add-subtask --parent=<id> --task-id=<existing-id>
+```
+
+## Smart Features
+
+1. **Automatic Subtask Generation**
+   - If title contains "and" or commas, create multiple
+   - Suggest common subtask patterns
+   - Inherit parent's context
+
+2. **Intelligent Defaults**
+   - Priority based on parent
+   - Appropriate time estimates
+   - Logical dependencies between subtasks
+
+3. **Validation**
+   - Check parent task complexity
+   - Warn if too many subtasks
+   - Ensure subtask makes sense
+
+## Creation Process
+
+1. Parse parent task context
+2. Generate subtask with ID like "5.1"
+3. Set appropriate defaults
+4. Link to parent task
+5. Update parent's time estimate
+
+## Example Flows
+
+```
+/project:tm/add-subtask to 5: implement user authentication
+→ Created subtask #5.1: "implement user authentication"
+→ Parent task #5 now has 1 subtask
+→ Suggested next subtasks: tests, documentation
+
+/project:tm/add-subtask 5: setup, implement, test
+→ Created 3 subtasks:
+  #5.1: setup
+  #5.2: implement  
+  #5.3: test
+```
+
+## Post-Creation
+
+- Show updated task hierarchy
+- Suggest logical next subtasks
+- Update complexity estimates
+- Recommend subtask order

assets/claude/commands/tm/add-subtask/convert-task-to-subtask.md

@@ -0,0 +1,71 @@
+Convert an existing task into a subtask.
+
+Arguments: $ARGUMENTS
+
+Parse parent ID and task ID to convert.
+
+## Task Conversion
+
+Converts an existing standalone task into a subtask of another task.
+
+## Argument Parsing
+
+- "move task 8 under 5"
+- "make 8 a subtask of 5"
+- "nest 8 in 5"
+- "5 8" → make task 8 a subtask of task 5
+
+## Execution
+
+```bash
+task-master add-subtask --parent=<parent-id> --task-id=<task-to-convert>
+```
+
+## Pre-Conversion Checks
+
+1. **Validation**
+   - Both tasks exist and are valid
+   - No circular parent relationships
+   - Task isn't already a subtask
+   - Logical hierarchy makes sense
+
+2. **Impact Analysis**
+   - Dependencies that will be affected
+   - Tasks that depend on converting task
+   - Priority alignment needed
+   - Status compatibility
+
+## Conversion Process
+
+1. Change task ID from "8" to "5.1" (next available)
+2. Update all dependency references
+3. Inherit parent's context where appropriate
+4. Adjust priorities if needed
+5. Update time estimates
+
+## Smart Features
+
+- Preserve task history
+- Maintain dependencies
+- Update all references
+- Create conversion log
+
+## Example
+
+```
+/project:tm/add-subtask/from-task 5 8
+→ Converting: Task #8 becomes subtask #5.1
+→ Updated: 3 dependency references
+→ Parent task #5 now has 1 subtask
+→ Note: Subtask inherits parent's priority
+
+Before: #8 "Implement validation" (standalone)
+After:  #5.1 "Implement validation" (subtask of #5)
+```
+
+## Post-Conversion
+
+- Show new task hierarchy
+- List updated dependencies
+- Verify project integrity
+- Suggest related conversions

assets/claude/commands/tm/add-task/add-task.md

@@ -0,0 +1,78 @@
+Add new tasks with intelligent parsing and context awareness.
+
+Arguments: $ARGUMENTS
+
+## Smart Task Addition
+
+Parse natural language to create well-structured tasks.
+
+### 1. **Input Understanding**
+
+I'll intelligently parse your request:
+- Natural language → Structured task
+- Detect priority from keywords (urgent, ASAP, important)
+- Infer dependencies from context
+- Suggest complexity based on description
+- Determine task type (feature, bug, refactor, test, docs)
+
+### 2. **Smart Parsing Examples**
+
+**"Add urgent task to fix login bug"**
+→ Title: Fix login bug
+→ Priority: high
+→ Type: bug
+→ Suggested complexity: medium
+
+**"Create task for API documentation after task 23 is done"**
+→ Title: API documentation
+→ Dependencies: [23]
+→ Type: documentation
+→ Priority: medium
+
+**"Need to refactor auth module - depends on 12 and 15, high complexity"**
+→ Title: Refactor auth module
+→ Dependencies: [12, 15]
+→ Complexity: high
+→ Type: refactor
+
+### 3. **Context Enhancement**
+
+Based on current project state:
+- Suggest related existing tasks
+- Warn about potential conflicts
+- Recommend dependencies
+- Propose subtasks if complex
+
+### 4. **Interactive Refinement**
+
+```yaml
+Task Preview:
+─────────────
+Title: [Extracted title]
+Priority: [Inferred priority]
+Dependencies: [Detected dependencies]
+Complexity: [Estimated complexity]
+
+Suggestions:
+- Similar task #34 exists, consider as dependency?
+- This seems complex, break into subtasks?
+- Tasks #45-47 work on same module
+```
+
+### 5. **Validation & Creation**
+
+Before creating:
+- Validate dependencies exist
+- Check for duplicates
+- Ensure logical ordering
+- Verify task completeness
+
+### 6. **Smart Defaults**
+
+Intelligent defaults based on:
+- Task type patterns
+- Team conventions
+- Historical data
+- Current sprint/phase
+
+Result: High-quality tasks from minimal input.

assets/claude/commands/tm/analyze-complexity/analyze-complexity.md

@@ -0,0 +1,121 @@
+Analyze task complexity and generate expansion recommendations.
+
+Arguments: $ARGUMENTS
+
+Perform deep analysis of task complexity across the project.
+
+## Complexity Analysis
+
+Uses AI to analyze tasks and recommend which ones need breakdown.
+
+## Execution Options
+
+```bash
+task-master analyze-complexity [--research] [--threshold=5]
+```
+
+## Analysis Parameters
+
+- `--research` → Use research AI for deeper analysis
+- `--threshold=5` → Only flag tasks above complexity 5
+- Default: Analyze all pending tasks
+
+## Analysis Process
+
+### 1. **Task Evaluation**
+For each task, AI evaluates:
+- Technical complexity
+- Time requirements
+- Dependency complexity
+- Risk factors
+- Knowledge requirements
+
+### 2. **Complexity Scoring**
+Assigns score 1-10 based on:
+- Implementation difficulty
+- Integration challenges
+- Testing requirements
+- Unknown factors
+- Technical debt risk
+
+### 3. **Recommendations**
+For complex tasks:
+- Suggest expansion approach
+- Recommend subtask breakdown
+- Identify risk areas
+- Propose mitigation strategies
+
+## Smart Analysis Features
+
+1. **Pattern Recognition**
+   - Similar task comparisons
+   - Historical complexity accuracy
+   - Team velocity consideration
+   - Technology stack factors
+
+2. **Contextual Factors**
+   - Team expertise
+   - Available resources
+   - Timeline constraints
+   - Business criticality
+
+3. **Risk Assessment**
+   - Technical risks
+   - Timeline risks
+   - Dependency risks
+   - Knowledge gaps
+
+## Output Format
+
+```
+Task Complexity Analysis Report
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+High Complexity Tasks (>7):
+📍 #5 "Implement real-time sync" - Score: 9/10
+   Factors: WebSocket complexity, state management, conflict resolution
+   Recommendation: Expand into 5-7 subtasks
+   Risks: Performance, data consistency
+
+📍 #12 "Migrate database schema" - Score: 8/10
+   Factors: Data migration, zero downtime, rollback strategy
+   Recommendation: Expand into 4-5 subtasks
+   Risks: Data loss, downtime
+
+Medium Complexity Tasks (5-7):
+📍 #23 "Add export functionality" - Score: 6/10
+   Consider expansion if timeline tight
+
+Low Complexity Tasks (<5):
+✅ 15 tasks - No expansion needed
+
+Summary:
+- Expand immediately: 2 tasks
+- Consider expanding: 5 tasks
+- Keep as-is: 15 tasks
+```
+
+## Actionable Output
+
+For each high-complexity task:
+1. Complexity score with reasoning
+2. Specific expansion suggestions
+3. Risk mitigation approaches
+4. Recommended subtask structure
+
+## Integration
+
+Results are:
+- Saved to `.taskmaster/reports/complexity-analysis.md`
+- Used by expand command
+- Inform sprint planning
+- Guide resource allocation
+
+## Next Steps
+
+After analysis:
+```
+/project:tm/expand 5    # Expand specific task
+/project:tm/expand/all  # Expand all recommended
+/project:tm/complexity-report  # View detailed report
+```