chore: add PRDs and surgical test generator agent

.changeset/chore-fix-docs.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": patch
+---
+
+Improve `analyze-complexity` cli docs and `--research` flag documentation

.changeset/config.json

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

.changeset/cursor-slash-commands.md

@@ -0,0 +1,7 @@
+---
+"task-master-ai": minor
+---
+
+Add Cursor IDE custom slash command support
+
+Expose Task Master commands as Cursor slash commands by copying assets/claude/commands to .cursor/commands on profile add and cleaning up on remove.

.changeset/curvy-weeks-flow.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": patch
+---
+
+Change parent task back to "pending" when all subtasks are in "pending" state

.changeset/mcp-timeout-configuration.md

@@ -0,0 +1,13 @@
+---
+"task-master-ai": minor
+---
+
+Enhanced Roo Code profile with MCP timeout configuration for improved reliability during long-running AI operations. The Roo profile now automatically configures a 300-second timeout for MCP server operations, preventing timeouts during complex tasks like `parse-prd`, `expand-all`, `analyze-complexity`, and `research` operations. This change also replaces static MCP configuration files with programmatic generation for better maintainability.
+
+**What's New:**
+- 300-second timeout for MCP operations (up from default 60 seconds)
+- Programmatic MCP configuration generation (replaces static asset files)
+- Enhanced reliability for AI-powered operations
+- Consistent with other AI coding assistant profiles
+
+**Migration:** No user action required - existing Roo Code installations will automatically receive the enhanced MCP configuration on next initialization.

.changeset/petite-ideas-grab.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": patch
+---
+
+Fix Claude Code settings validation for pathToClaudeCodeExecutable

.changeset/silly-pandas-find.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": patch
+---
+
+Fix sonar deep research model failing, should be called `sonar-deep-research`

.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/surgical-test-generator.md

@@ -0,0 +1,245 @@
+---
+name: surgical-test-generator
+description: Use this agent when you need to generate comprehensive, production-grade test suites for existing code. This includes: analyzing code paths and failure modes, detecting untestable patterns, generating unit/integration tests, following project test conventions, focusing on real-world edge cases, and ensuring deterministic test execution. The agent specializes in catching bugs that matter, not inflating coverage metrics.
+
+Examples:
+<example>
+Context: The user wants tests for a specific function they just wrote.
+user: "I need tests for this validatePayment function that handles credit card processing"
+assistant: "I'll use the surgical-test-generator agent to analyze the validatePayment function's code paths, identify critical edge cases like invalid card numbers and network failures, and generate comprehensive tests following your project's conventions."
+<commentary>
+User needs specific function testing - the agent will analyze paths, boundaries, and failure modes for payment validation.
+</commentary>
+</example>
+<example>
+Context: The user has untested legacy code that needs coverage.
+user: "We have this 500-line OrderProcessor class with zero tests and it's causing production issues"
+assistant: "I'll invoke the surgical-test-generator agent to map all the code paths in OrderProcessor, prioritize tests for the riskiest behaviors, and generate a test suite that catches the bugs most likely to cause production failures."
+<commentary>
+Legacy code without tests - the agent will prioritize high-risk paths and realistic failure scenarios over complete coverage.
+</commentary>
+</example>
+<example>
+Context: The user wants to improve test quality, not just coverage.
+user: "Our tests pass but we still get production bugs. Can you review this API handler and suggest better tests?"
+assistant: "I'll use the surgical-test-generator agent to identify gaps in your current test coverage, focusing on real-world edge cases like concurrent requests, malformed input, and external service failures that often slip through basic tests."
+<commentary>
+Existing tests missing edge cases - the agent will focus on adversarial scenarios and production-like failures.
+</commentary>
+</example>
+model: opus
+color: blue
+---
+
+You are a principal software engineer specializing in surgical, high-signal test generation. You write tests that catch real bugs before they reach production, focusing on actual failure modes over coverage metrics. You reason about control flow, data flow, mutation, concurrency, and security to design tests that surface defects early.
+
+## Core Capabilities
+
+### Multi-Perspective Analysis
+You sequentially analyze code through five expert lenses:
+1. **Context Profiling**: Identify language, frameworks, build tools, and existing test patterns
+2. **Path Analysis**: Map all reachable paths including happy, error, and exceptional flows
+3. **Adversarial Thinking**: Enumerate realistic failures, boundaries, and misuse patterns
+4. **Risk Prioritization**: Rank by production impact and likelihood, discard speculative cases
+5. **Test Scaffolding**: Generate deterministic, isolated tests following project conventions
+
+### Edge Case Expertise
+You focus on failures that actually occur in production:
+- **Data Issues**: Null/undefined, empty collections, malformed UTF-8, mixed line endings
+- **Numeric Boundaries**: -1, 0, 1, MAX values, floating-point precision, integer overflow
+- **Temporal Pitfalls**: DST transitions, leap years, timezone bugs, date parsing ambiguities
+- **Collection Problems**: Off-by-one errors, concurrent modification, performance at scale
+- **State Violations**: Out-of-order calls, missing initialization, partial updates
+- **External Failures**: Network timeouts, malformed responses, retry storms, connection exhaustion
+- **Concurrency Bugs**: Race conditions, deadlocks, promise leaks, thread starvation
+- **Resource Limits**: Memory spikes, file descriptor leaks, connection pool saturation
+- **Security Surfaces**: Injection attacks, path traversal, privilege escalation
+
+### Framework Intelligence
+You auto-detect and follow existing test patterns:
+- **JavaScript/TypeScript**: Jest, Vitest, Mocha, or project wrappers
+- **Python**: pytest, unittest with appropriate fixtures
+- **Java/Kotlin**: JUnit 5, TestNG with proper annotations
+- **C#/.NET**: xUnit.net preferred, NUnit/MSTest if dominant
+- **Go**: Built-in testing package with table-driven tests
+- **Rust**: Standard #[test] with proptest for properties
+- **Swift**: XCTest or Swift Testing based on project
+- **C/C++**: GoogleTest or Catch2 matching build system
+
+## Your Workflow
+
+### Phase 1: Code Analysis
+You examine the provided code to understand:
+- Public API surfaces and contracts
+- Internal helper functions and their criticality
+- External dependencies and I/O operations
+- State management and mutation patterns
+- Error handling and recovery paths
+- Concurrency and async operations
+
+### Phase 2: Test Strategy Development
+You determine the optimal testing approach:
+- Start from public APIs, work inward to critical helpers
+- Test behavior not implementation unless white-box needed
+- Prefer property-based tests for algebraic domains
+- Use minimal stubs/mocks, prefer in-memory fakes
+- Flag untestable code with refactoring suggestions
+- Include stress tests for concurrency issues
+
+### Phase 3: Test Generation
+You create tests that:
+- Follow project's exact style and conventions
+- Use clear Arrange-Act-Assert or Given-When-Then
+- Execute in under 100ms without external calls
+- Remain deterministic with seeded randomness
+- Self-document through descriptive names
+- Explain failures clearly with context
+
+## Detection Patterns
+
+### When analyzing a pure function:
+- Test boundary values and type edges
+- Verify mathematical properties hold
+- Check error propagation
+- Consider numeric overflow/underflow
+
+### When analyzing stateful code:
+- Test initialization sequences
+- Verify state transitions
+- Check concurrent access patterns
+- Validate cleanup and teardown
+
+### When analyzing I/O operations:
+- Test success paths with valid data
+- Simulate network failures and timeouts
+- Check malformed input handling
+- Verify resource cleanup on errors
+
+### When analyzing async code:
+- Test promise resolution and rejection
+- Check cancellation handling
+- Verify timeout behavior
+- Validate error propagation chains
+
+## Test Quality Standards
+
+### Coverage Philosophy
+You prioritize catching real bugs over metrics:
+- Critical paths get comprehensive coverage
+- Edge cases get targeted scenarios
+- Happy paths get basic validation
+- Speculative cases get skipped
+
+### Test Independence
+Each test you generate:
+- Runs in isolation without shared state
+- Cleans up all resources
+- Uses fixed seeds for randomness
+- Mocks time when necessary
+
+### Failure Diagnostics
+Your tests provide clear failure information:
+- Descriptive test names that explain intent
+- Assertions that show expected vs actual
+- Context about what was being tested
+- Hints about likely failure causes
+
+## Special Considerations
+
+### When NOT to Generate Tests
+You recognize when testing isn't valuable:
+- Generated code that's guaranteed correct
+- Simple getters/setters without logic
+- Framework boilerplate
+- Code scheduled for deletion
+
+### Untestable Code Patterns
+You identify and flag:
+- Hard-coded external dependencies
+- Global state mutations
+- Time-dependent behavior without injection
+- Random behavior without seeds
+
+### Performance Testing
+When relevant, you include:
+- Benchmarks for critical paths
+- Memory usage validation
+- Concurrent load testing
+- Resource leak detection
+
+## Output Format
+
+You generate test code that:
+
+```[language]
+// Clear test description
+test('should [specific behavior] when [condition]', () => {
+    // Arrange - Set up test data and dependencies
+    
+    // Act - Execute the code under test
+    
+    // Assert - Verify the outcome
+});
+```
+
+## Framework-Specific Patterns
+
+### JavaScript/TypeScript (Jest/Vitest)
+- Use describe blocks for grouping
+- Leverage beforeEach/afterEach for setup
+- Mock modules with jest.mock()/vi.fn, vi.mock or vi.spyOn
+- Use expect matchers appropriately
+
+### Python (pytest)
+- Use fixtures for reusable setup
+- Apply parametrize for data-driven tests
+- Leverage pytest markers for categorization
+- Use clear assertion messages
+
+### Java (JUnit 5)
+- Apply appropriate annotations
+- Use nested classes for grouping
+- Leverage parameterized tests
+- Include display names
+
+### C# (xUnit)
+- Use Theory for data-driven tests
+- Apply traits for categorization
+- Leverage fixtures for setup
+- Use fluent assertions when available
+
+## Request Handling
+
+### Specific Test Requests
+When asked for specific tests:
+- Focus only on the requested scope
+- Don't generate broader coverage unless asked
+- Provide targeted, high-value scenarios
+- Include rationale for test choices
+
+### Comprehensive Coverage Requests
+When asked for full coverage:
+- Start with critical paths
+- Add edge cases progressively
+- Group related tests logically
+- Flag if multiple files needed
+
+### Legacy Code Testing
+When testing untested code:
+- Prioritize high-risk areas first
+- Add characterization tests
+- Suggest refactoring for testability
+- Focus on preventing regressions
+
+## Communication Guidelines
+
+You always:
+- Explain why each test matters
+- Document test intent clearly
+- Note any assumptions made
+- Highlight untestable patterns
+- Suggest improvements when relevant
+- Follow existing project style exactly
+- Generate only essential test code
+
+When you need additional context like test frameworks or existing patterns, you ask specifically for those files. You focus on generating tests that will actually catch bugs in production, not tests that merely increase coverage numbers. Every test you write has a clear purpose and tests a realistic scenario.

.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
+/project:tm/expand 5    # Expand specific task
-/taskmaster:expand-all  # Expand all recommended
+/project:tm/expand/all  # Expand all recommended
-/taskmaster:complexity-report  # View detailed report
+/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
+/project:tm/add-task create user authentication system
-/taskmaster:update mark all API tasks as high priority
+/project:tm/update mark all API tasks as high priority
-/taskmaster:list show blocked tasks
+/project:tm/list show blocked tasks
 ```
 
 ### ID-Based Commands
 Commands requiring IDs intelligently parse from $ARGUMENTS:
 ```
-/taskmaster:show 45
+/project:tm/show 45
-/taskmaster:expand 23
+/project:tm/expand 23
-/taskmaster:set-status/to-done 67
+/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

.github/workflows/extension-ci.yml

@@ -41,7 +41,8 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-node-
 
-      - name: Install Monorepo Dependencies
+      - name: Install Extension Dependencies
+        working-directory: apps/extension
         run: npm ci
         timeout-minutes: 5
 
@@ -67,6 +68,7 @@ jobs:
             ${{ runner.os }}-node-
 
       - name: Install if cache miss
+        working-directory: apps/extension
         run: npm ci
         timeout-minutes: 3
 
@@ -98,6 +100,7 @@ jobs:
             ${{ runner.os }}-node-
 
       - name: Install if cache miss
+        working-directory: apps/extension
         run: npm ci
         timeout-minutes: 3
 

.github/workflows/extension-release.yml

@@ -31,7 +31,8 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-node-
 
-      - name: Install Monorepo Dependencies
+      - name: Install Extension Dependencies
+        working-directory: apps/extension
         run: npm ci
         timeout-minutes: 5
 

.taskmaster/docs/prd-autonomous-tdd-rails.md

@@ -0,0 +1,220 @@
+# PRD: Autonomous TDD + Git Workflow (On Rails)
+
+## Summary
+- Put the existing git and test workflows on rails: a repeatable, automated process that can run autonomously, with guardrails and a compact TUI for visibility.
+- Flow: for a selected task, create a branch named with the tag + task id → generate tests for the first subtask (red) using the Surgical Test Generator → implement code (green) → verify tests → commit → repeat per subtask → final verify → push → open PR against the default branch.
+- Build on existing rules: `.cursor/rules/git_workflow.mdc`, `.cursor/rules/test_workflow.mdc`, `.claude/agents/surgical-test-generator.md`, and existing CLI/core services.
+
+## Goals
+- Deterministic, resumable automation to execute the TDD loop per subtask with minimal human intervention.
+- Strong guardrails: never commit to the default branch; only commit when tests pass; enforce status transitions; persist logs/state for debuggability.
+- Visibility: a compact terminal UI (like lazygit) to pick tag, view tasks, and start work; right-side pane opens an executor terminal (via tmux) for agent coding.
+- Extensible: framework-agnostic test generation via the Surgical Test Generator; detect and use the repo’s test command for execution with coverage thresholds.
+
+## Non‑Goals (initial)
+- Full multi-language runner parity beyond detection and executing the project’s test command.
+- Complex GUI; start with CLI/TUI + tmux pane. IDE/extension can hook into the same state later.
+- Rich executor selection UX (codex/gemini/claude) — we’ll prompt per run; defaults can come later.
+
+## Success Criteria
+- One command can autonomously complete a task’s subtasks via TDD and open a PR when done.
+- All commits made on a branch that includes the tag and task id (see Branch Naming); no commits to the default branch directly.
+- Every subtask iteration: failing tests added first (red), then code added to pass them (green), commit only after green.
+- End-to-end logs + artifacts stored in `.taskmaster/reports/runs/<timestamp-or-id>/`.
+
+## User Stories
+- As a developer, I can run `tm autopilot <taskId>` and watch a structured, safe workflow execute.
+- As a reviewer, I can inspect commits per subtask, and a PR summarizing the work when the task completes.
+- As an operator, I can see current step, active subtask, tests status, and logs in a compact CLI view and read a final run report.
+
+## High‑Level Workflow
+1) Pre‑flight
+   - Verify clean working tree or confirm staging/commit policy (configurable).
+   - Detect repo type and the project’s test command (e.g., `npm test`, `pnpm test`, `pytest`, `go test`).
+   - Validate tools: `git`, `gh` (optional for PR), `node/npm`, and (if used) `claude` CLI.
+   - Load TaskMaster state and selected task; if no subtasks exist, automatically run “expand” before working.
+
+2) Branch & Tag Setup
+   - Checkout default branch and update (optional), then create a branch using Branch Naming (below).
+   - Map branch ↔ tag via existing tag management; explicitly set active tag to the branch’s tag.
+
+3) Subtask Loop (for each pending/in-progress subtask in dependency order)
+   - Select next eligible subtask using `tm-core` TaskService `getNextTask()` and subtask eligibility logic.
+   - Red: generate or update failing tests for the subtask
+     - Use the Surgical Test Generator system prompt (`.claude/agents/surgical-test-generator.md`) to produce high-signal tests following project conventions.
+     - Run tests to confirm red; record results. If not red (already passing), skip to next subtask or escalate.
+   - Green: implement code to pass tests
+     - Use executor to implement changes (initial: `claude` CLI prompt with focused context).
+     - Re-run tests until green or timeout/backoff policy triggers.
+   - Commit: when green
+     - Commit tests + code with conventional commit message. Optionally update subtask status to `done`.
+     - Persist run step metadata/logs.
+
+4) Finalization
+   - Run full test suite and coverage (if configured); optionally lint/format.
+   - Commit any final adjustments.
+   - Push branch (ask user to confirm); create PR (via `gh pr create`) targeting the default branch. Title format: `Task #<id> [<tag>]: <title>`.
+
+5) Post‑Run
+   - Update task status if desired (e.g., `review`).
+   - Persist run report (JSON + markdown summary) to `.taskmaster/reports/runs/<run-id>/`.
+
+## Guardrails
+- Never commit to the default branch.
+- Commit only if all tests (targeted and suite) pass; allow override flags.
+- Enforce 80% coverage thresholds (lines/branches/functions/statements) by default; configurable.
+- Timebox/model ops and retries; if not green within N attempts, pause with actionable state for resume.
+- Always log actions, commands, and outcomes; include dry-run mode.
+- Ask before branch creation, pushing, and opening a PR unless `--no-confirm` is set.
+
+## Integration Points (Current Repo)
+- CLI: `apps/cli` provides command structure and UI components.
+  - New command: `tm autopilot` (alias: `task-master autopilot`).
+  - Reuse UI components under `apps/cli/src/ui/components/` for headers/task details/next-task.
+- Core services: `packages/tm-core`
+  - `TaskService` for selection, status, tags.
+  - `TaskExecutionService` for prompt formatting and executor prep.
+  - Executors: `claude` executor and `ExecutorFactory` to run external tools.
+  - Proposed new: `WorkflowOrchestrator` to drive the autonomous loop and emit progress events.
+- Tag/Git utilities: `scripts/modules/utils/git-utils.js` and `scripts/modules/task-manager/tag-management.js` for branch→tag mapping and explicit tag switching.
+- Rules: `.cursor/rules/git_workflow.mdc` and `.cursor/rules/test_workflow.mdc` to steer behavior and ensure consistency.
+- Test generation prompt: `.claude/agents/surgical-test-generator.md`.
+
+## Proposed Components
+- Orchestrator (tm-core): `WorkflowOrchestrator` (new)
+  - State machine driving phases: Preflight → Branch/Tag → SubtaskIter (Red/Green/Commit) → Finalize → PR.
+  - Exposes an evented API (progress events) that the CLI can render.
+  - Stores run state artifacts.
+
+- Test Runner Adapter
+  - Detects and runs tests via the project’s test command (e.g., `npm test`), with targeted runs where feasible.
+  - API: runTargeted(files/pattern), runAll(), report summary (failures, duration, coverage), enforce 80% threshold by default.
+
+- Git/PR Adapter
+  - Encapsulates `git` ops: branch create/checkout, add/commit, push.
+  - Optional `gh` integration to open PR; fallback to instructions if `gh` unavailable.
+  - Confirmation gates for branch creation and pushes.
+  - Adds commit footers and a unified trailer (`Refs: TM-<tag>-<id>[.<sub>]`) for robust mapping to tasks/subtasks.
+
+- Prompt/Exec Adapter
+  - Uses existing executor service to call the selected coding assistant (initially `claude`) with tight prompts: task/subtask context, surgical tests first, then minimal code to green.
+
+- Run State + Reporting
+  - JSONL log of steps, timestamps, commands, test results.
+  - Markdown summary for PR description and post-run artifact.
+
+## CLI UX (MVP)
+- Command: `tm autopilot [taskId]`
+  - Flags: `--dry-run`, `--no-push`, `--no-pr`, `--no-confirm`, `--force`, `--max-attempts <n>`, `--runner <auto|custom>`, `--commit-scope <scope>`
+  - Output: compact header (project, tag, branch), current phase, subtask line, last test summary, next actions.
+- Resume: If interrupted, `tm autopilot --resume` picks up from last checkpoint in run state.
+
+### TUI with tmux (Linear Execution)
+- Left pane: Tag selector, task list (status/priority), start/expand shortcuts; “Start” triggers the next task or a selected task.
+- Right pane: Executor terminal (tmux split) that runs the coding agent (claude-code/codex). Autopilot can hand over to the right pane during green.
+- MCP integration: use MCP tools for task queries/updates and for shell/test invocations where available.
+
+## Prompts (Initial Direction)
+- Red phase prompt skeleton (tests):
+  - Use `.claude/agents/surgical-test-generator.md` as the system prompt to generate high-signal failing tests tailored to the project’s language and conventions. Keep scope minimal and deterministic; no code changes yet.
+- Green phase prompt skeleton (code):
+  - “Make the tests pass by changing the smallest amount of code, following project patterns. Only modify necessary files. Keep commits focused to this subtask.”
+
+## Configuration
+- `.taskmaster/config.json` additions
+  - `autopilot`: `{ enabled: true, requireCleanWorkingTree: true, commitTemplate: "{type}({scope}): {msg}", defaultCommitType: "feat" }`
+  - `test`: `{ runner: "auto", coverageThresholds: { lines: 80, branches: 80, functions: 80, statements: 80 } }`
+  - `git`: `{ branchPattern: "{tag}/task-{id}-{slug}", pr: { enabled: true, base: "default" }, commitFooters: { task: "Task-Id", subtask: "Subtask-Id", tag: "Tag" }, commitTrailer: "Refs: TM-{tag}-{id}{.sub?}" }`
+
+## Decisions
+- Use conventional commits plus footers and a unified trailer `Refs: TM-<tag>-<id>[.<sub>]` for all commits; Git/PR adapter is responsible for injecting these.
+
+## Risks and Mitigations
+- Model hallucination/large diffs: restrict prompt scope; enforce minimal changes; show diff previews (optional) before commit.
+- Flaky tests: allow retries, isolate targeted runs for speed, then full suite before commit.
+- Environment variability: detect runners/tools; provide fallbacks and actionable errors.
+- PR creation fails: still push and print manual commands; persist PR body to reuse.
+
+## Open Questions
+1) Slugging rules for branch names; any length limits or normalization beyond `{slug}` token sanitize?
+2) PR body standard sections beyond run report (e.g., checklist, coverage table)?
+3) Default executor prompt fine-tuning once codex/gemini integration is available.
+4) Where to store persistent TUI state (pane layout, last selection) in `.taskmaster/state.json`?
+
+## Branch Naming
+- Include both the tag and the task id in the branch name to make lineage explicit.
+- Default pattern: `<tag>/task-<id>[-slug]` (e.g., `master/task-12`, `tag-analytics/task-4-user-auth`).
+- Configurable via `.taskmaster/config.json`: `git.branchPattern` supports tokens `{tag}`, `{id}`, `{slug}`.
+
+## PR Base Branch
+- Use the repository’s default branch (detected via git) unless overridden.
+- Title format: `Task #<id> [<tag>]: <title>`.
+
+## RPG Mapping (Repository Planning Graph)
+
+Functional nodes (capabilities):
+- Autopilot Orchestration → drives TDD loop and lifecycle
+- Test Generation (Surgical) → produces failing tests from subtask context
+- Test Execution + Coverage → runs suite, enforces thresholds
+- Git/Branch/PR Management → safe operations and PR creation
+- TUI/Terminal Integration → interactive control and visibility via tmux
+- MCP Integration → structured task/status/context operations
+
+Structural nodes (code organization):
+- `packages/tm-core`:
+  - `services/workflow-orchestrator.ts` (new)
+  - `services/test-runner-adapter.ts` (new)
+  - `services/git-adapter.ts` (new)
+  - existing: `task-service.ts`, `task-execution-service.ts`, `executors/*`
+- `apps/cli`:
+  - `src/commands/autopilot.command.ts` (new)
+  - `src/ui/tui/` (new tmux/TUI helpers)
+- `scripts/modules`:
+  - reuse `utils/git-utils.js`, `task-manager/tag-management.js`
+- `.claude/agents/`:
+  - `surgical-test-generator.md`
+
+Edges (data/control flow):
+- Autopilot → Test Generation → Test Execution → Git Commit → loop
+- Autopilot → Git Adapter (branch, tag, PR)
+- Autopilot → TUI (event stream) → tmux pane control
+- Autopilot → MCP tools for task/status updates
+- Test Execution → Coverage gate → Autopilot decision
+
+Topological traversal (implementation order):
+1) Git/Test adapters (foundations)
+2) Orchestrator skeleton + events
+3) CLI `autopilot` command and dry-run
+4) Surgical test-gen integration and execution gate
+5) PR creation, run reports, resumability
+
+## Phased Roadmap
+- Phase 0: Spike
+  - Implement CLI skeleton `tm autopilot` with dry-run showing planned steps from a real task + subtasks.
+  - Detect test runner (package.json) and git state; render a preflight report.
+
+- Phase 1: Core Rails
+  - Implement `WorkflowOrchestrator` in `tm-core` with event stream; add Git/Test adapters.
+  - Support subtask loop (red/green/commit) with framework-agnostic test generation and detected test command; commit gating on passing tests and coverage.
+  - Branch/tag mapping via existing tag-management APIs.
+  - Run report persisted under `.taskmaster/reports/runs/`.
+
+- Phase 2: PR + Resumability
+  - Add `gh` PR creation with well-formed body using the run report.
+  - Introduce resumable checkpoints and `--resume` flag.
+  - Add coverage enforcement and optional lint/format step.
+
+- Phase 3: Extensibility + Guardrails
+  - Add support for basic pytest/go test adapters.
+  - Add safeguards: diff preview mode, manual confirm gates, aggressive minimal-change prompts.
+  - Optional: small TUI panel and extension panel leveraging the same run state file.
+
+## References (Repo)
+- Test Workflow: `.cursor/rules/test_workflow.mdc`
+- Git Workflow: `.cursor/rules/git_workflow.mdc`
+- CLI: `apps/cli/src/commands/start.command.ts`, `apps/cli/src/ui/components/*.ts`
+- Core Services: `packages/tm-core/src/services/task-service.ts`, `task-execution-service.ts`
+- Executors: `packages/tm-core/src/executors/*`
+- Git Utilities: `scripts/modules/utils/git-utils.js`
+- Tag Management: `scripts/modules/task-manager/tag-management.js`
+ - Surgical Test Generator: `.claude/agents/surgical-test-generator.md`

.taskmaster/docs/prd-rpg-user-stories.md

@@ -0,0 +1,221 @@
+# PRD: RPG‑Based User Story Mode + Validation‑First Delivery
+
+## Summary
+- Introduce a “User Story Mode” where each Task is a user story and each Subtask is a concrete implementation step. Enable via config flag; when enabled, Task generation and PRD parsing produce user‑story titles/details with acceptance criteria, while Subtasks capture implementation details.
+- Build a validation‑first delivery pipeline: derive tests from acceptance criteria (Surgical Test Generator), wire TDD rails and Git/PR mapping so reviews focus on verification rather than code spelunking.
+- Keep everything on rails: branch naming with tag+task id, commit/PR linkage to tasks/subtasks, coverage + test gates, and lightweight TUI for fast execution.
+
+## North‑Star Outcomes
+- Humans stay in briefs/frontends; implementation runs quickly, often without opening the IDE.
+- “Definition of Done” is expressed and enforced as tests; business logic is encoded in test criteria/acceptance criteria.
+- End‑to‑end linkage from brief → user story → subtasks → commits/PRs → delivery, with reproducible automation and minimal ceremony.
+
+## Problem
+- The bottleneck is validation and PR review, not code generation. Plans are helpful but the chokepoint is proving correctness, business conformance, and integration.
+- Current test workflow is too Jest‑specific; we need framework‑agnostic generation and execution.
+- We need consistent Git/TDD wiring so GitHub integrations can map work artifacts to tasks/subtasks without ambiguity.
+
+## Solution Overview
+- Add a configuration flag to switch to user story mode and adapt prompts/parsers.
+- Expand tasks with explicit Acceptance Criteria and Test Criteria; drive Surgical Test Generator to create failing tests first; wire autonomous TDD loops per subtask until green, then commit.
+- Enforce coverage (80% default) and generate PRs that summarize user story, acceptance criteria coverage, and test results; commits/PRs contain metadata to link back to tasks/subtasks.
+- Provide a compact TUI (tmux) to pick tag/tasks and launch an executor terminal, while the orchestrator runs rails in the background.
+
+---
+
+## Configuration
+- `.taskmaster/config.json` additions
+  - `stories`: `{ enabled: true, storyLabel: "User Story", acceptanceKey: "Acceptance Criteria" }`
+  - `autopilot`: `{ enabled: true, requireCleanWorkingTree: true }`
+  - `test`: `{ runner: "auto", coverageThresholds: { lines: 80, branches: 80, functions: 80, statements: 80 } }`
+  - `git`: `{ branchPattern: "{tag}/task-{id}-{slug}", pr: { enabled: true, base: "default" }, commitFooters: { task: "Task-Id", subtask: "Subtask-Id", tag: "Tag" } }`
+
+Behavior when `stories.enabled=true`:
+- Task generation prompts and PRD parsers produce user‑story formatted titles and descriptions, include acceptance criteria blocks, and set `task.type = 'user_story'`.
+- Subtasks remain implementation steps with concise technical goals.
+- Expand will ensure any missing acceptance criteria is synthesized (from brief/PRD content) before starting work.
+
+---
+
+## Data Model Changes
+- Task fields (add):
+  - `type: 'user_story' | 'technical'` (default `technical`)
+  - `acceptanceCriteria: string[] | string` (structured or markdown)
+  - `testCriteria: string[] | string` (optional, derived from acceptance criteria; what to validate)
+- Subtask fields remain focused on implementation detail and dependency graph.
+
+Storage and UI remain backward compatible; fields are optional when `stories.enabled=false`.
+
+### JSON Gherkin Representation (for stories)
+Add an optional `gherkin` block to Tasks in story mode. Keep Hybrid acceptanceCriteria as the human/authoring surface; maintain a normalized JSON Gherkin for deterministic mapping.
+
+```
+GherkinFeature {
+  id: string,                   // FEAT-<taskId>
+  name: string,                 // mirrors user story title
+  description?: string,
+  background?: { steps: Step[] },
+  scenarios: Scenario[]
+}
+
+Scenario {
+  id: string,                   // SC-<taskId>-<n> or derived from AC id
+  name: string,
+  tags?: string[],
+  steps: Step[],                // Given/When/Then/And/But
+  examples?: Record<string, any>[]
+}
+
+Step { keyword: 'Given'|'When'|'Then'|'And'|'But', text: string }
+```
+
+Notes
+- Derive `gherkin.scenarios` from acceptanceCriteria when obvious; preserve both raw markdown and normalized items.
+- Allow cross‑references between scenarios and AC items (e.g., `refs: ['AC-12-1']`).
+
+---
+
+## RPG Plan (Repository Planning Graph)
+
+Functional Nodes (Capabilities)
+- Brief Intake → parse briefs/PRDs and extract user stories (when enabled)
+- User Story Generation → create task title/details as user stories + acceptance criteria
+- JSON Gherkin Synthesis → produce Feature/Scenario structure from acceptance criteria
+- Acceptance/Test Criteria Synthesis → convert acceptance criteria into concrete test criteria
+- Surgical Test Generation → generate failing tests per subtask using `.claude/agents/surgical-test-generator.md`
+- Implementation Planning → expand subtasks as atomic implementation steps with dependencies
+- Autonomous Execution (Rails) → branch, red/green loop per subtask, commit when green
+- Validation & Review Automation → coverage gates, PR body with user story + results, checklist
+- GitHub Integration Mapping → branch naming, commit footers, PR linkage to tasks/subtasks
+- TUI/Terminal Integration → tag/task selection left pane; executor terminal right pane via tmux
+
+Structural Nodes (Code Organization)
+- `packages/tm-core`
+  - `services/workflow-orchestrator.ts` (new): drives rails, emits progress events
+  - `services/story-mode.service.ts` (new): toggles prompts/parsers for user stories, acceptance criteria
+  - `services/test-runner-adapter.ts` (new): detects/executes project test command, collects coverage
+  - `services/git-adapter.ts` (new): branch/commit/push, PR creation; applies commit footers
+  - existing: `task-service.ts`, `task-execution-service.ts`, `executors/*`
+- `apps/cli`
+  - `src/commands/autopilot.command.ts` (new): orchestrates a full run; supports `--stories`
+  - `src/ui/tui/` (new): tmux helpers and compact panes for selection and logs
+- `scripts/modules`
+  - reuse `utils/git-utils.js`, `task-manager/tag-management.js`, PR template utilities
+- `.cursor/rules`
+  - update generation/parsing rules to emit user‑story format when enabled
+- `.claude/agents`
+  - existing: `surgical-test-generator.md` for red phase
+
+Edges (Dependencies / Data Flow)
+- Brief Intake → User Story Generation → Acceptance/Test Criteria Synthesis → Implementation Planning → Autonomous Execution → Validation/PR
+- Execution ↔ Test Runner (runAll/runTargeted, coverage) → back to Execution for decisions
+- Git Adapter ← Execution (commits/branch) → PR creation (target default branch)
+- TUI ↔ Orchestrator (event stream) → user confirmations for branch/push/PR
+- MCP Tools ↔ Orchestrator for task/status/context updates
+
+Topological Traversal (Build Order)
+1) Config + Data Model changes (stories flag, acceptance fields, optional `gherkin`)
+2) Rules/Prompts updates for parsing/generation in story mode (emit AC Hybrid + JSON Gherkin)
+3) Test Runner Adapter (framework‑agnostic execute + coverage)
+4) Git Adapter (branch pattern `{tag}/task-{id}-{slug}`, commit footers/trailer, PR create)
+5) Workflow Orchestrator wiring red/green/commit loop with coverage gate and scenario iteration
+6) Surgical Test Gen integration (red) from JSON Gherkin + AC; minimal‑change impl prompts (green)
+7) CLI autopilot (dry‑run → full run) and TUI (tmux panes)
+8) PR template and review automation (user story, AC table with test links, scenarios, coverage)
+
+---
+
+## Git/TDD Wiring (Validation‑First)
+- Branch naming: include tag + task id (e.g., `master/task-12-user-auth`) to disambiguate context.
+- Commit footers (configurable):
+  - `Task-Id: <id>`
+  - `Subtask-Id: <id>.<sub>` when relevant
+  - `Tag: <tag>`
+  - Trailer: `Refs: TM-<tag>-<id>[.<sub>] SC:<scenarioId> AC:<acId>`
+- Red/Green/Commit loop per subtask:
+  - Red: synthesize failing tests from acceptance criteria (Surgical agent)
+  - Green: minimal code to pass; re‑run full suite
+  - Commit when all tests pass and coverage ≥ 80%
+- PR base: repository default branch. Title `Task #<id> [<tag>]: <title>`.
+- PR body sections: User Story, Acceptance Criteria, Subtask Summary, Test Results, Coverage Table, Linked Work Items (ids), Next Steps.
+
+---
+
+## Prompts & Parsers (Story Mode)
+- PRD/Brief Parser updates:
+  - Extract user stories with “As a … I want … so that …” format when present.
+  - Extract Acceptance Criteria as bullet list; fill gaps with LLM synthesis from brief context.
+  - Emit JSON Gherkin Feature/Scenarios; auto‑split Given/When/Then when feasible; otherwise store text under `then` and refine later.
+- Task Generation Prompt (story mode):
+  - “Generate a task as a User Story with clear Acceptance Criteria. Do not include implementation details in the story; produce implementation subtasks separately.”
+- Subtask Generation Prompt:
+  - “Produce technical implementation steps to satisfy the acceptance criteria. Each subtask should be atomic and testable.”
+- Test Generation (Red):
+  - Use `.claude/agents/surgical-test-generator.md`; seed with JSON Gherkin + Acceptance/Test Criteria; determinism favored over maximum coverage.
+  - Record produced test paths back into AC items and optionally scenario annotations.
+- Implementation (Green):
+  - Minimal diffs, follow patterns, keep commits scoped to the subtask.
+
+---
+
+## TUI (Linear, tmux‑based)
+- Left: Tag selector and task list (status/priority). Actions: Expand, Start (Next or Selected), Review.
+- Right: Executor terminal (claude‑code/codex) under tmux split; orchestrator logs under another pane.
+- Confirmations inline (branch create, push, PR) unless `--no-confirm`.
+
+---
+
+## Migration & Backward Compatibility
+- Optional `gherkin` block; existing tasks remain valid.
+- When `stories.enabled=true`, new tasks include AC Hybrid + `gherkin`; upgrade path via a utility to synthesize both from description/testStrategy/acceptanceCriteria.
+
+---
+
+## Risks & Mitigations
+- Hallucinated acceptance criteria → Always show criteria in PR; allow quick amend and re‑run.
+- Framework variance → Test Runner Adapter detects and normalizes execution/coverage; fallback to `test` script.
+- Large diffs → Prompt for minimal changes; allow diff preview before commit.
+- Flaky tests → Retry policy; isolate targeted runs; enforce passing full suite before commit.
+
+---
+
+## Acceptance Criteria Schema Options (for decision)
+- Option A: Markdown only
+  - Pros: simple to write/edit, good for humans
+  - Cons: hard to map deterministically to tests; weak traceability; brittle diffs
+- Option B: Structured array
+  - Example: `{ id, summary, given, when, then, severity, tags }`
+  - Pros: machine‑readable; strong linking to tests/coverage; easy to diff
+  - Cons: heavier authoring; requires schema discipline
+- Option C: Hybrid (recommended)
+  - Store both: a normalized array of criteria objects and a preserved `raw` markdown block
+  - Each criterion gets a stable `id` (e.g., `AC-<taskId>-<n>`) used in tests, commit trailers, and PR tables
+  - Enables clean PR tables and deterministic coverage mapping while keeping human‑friendly text
+
+Proposed default schema (hybrid):
+```
+acceptanceCriteria: {
+  raw: """
+  - AC1: Guest can checkout with credit card
+  - AC2: Declined cards show error inline
+  """,
+  items: [
+    {
+      id: "AC-12-1",
+      summary: "Guest can checkout with credit card",
+      given: "a guest with items in cart",
+      when: "submits valid credit card",
+      then: "order is created and receipt emailed",
+      severity: "must",
+      tags: ["checkout", "payments"],
+      tests: [] // filled by orchestrator (file paths/test IDs)
+    }
+  ]
+}
+```
+
+Decision: adopt Hybrid default; allow Markdown‑only input and auto‑normalize.
+
+## Decisions
+- Adopt Hybrid acceptance criteria schema by default; normalize Markdown to structured items with stable IDs `AC-<taskId>-<n>`.
+- Use conventional commits plus footers and a unified trailer `Refs: TM-<tag>-<id>[.<sub>]` across PRDs for robust mapping.

.taskmaster/templates/example_prd_rpg.txt

@@ -1,511 +0,0 @@
-<rpg-method>
-# Repository Planning Graph (RPG) Method - PRD Template
-
-This template teaches you (AI or human) how to create structured, dependency-aware PRDs using the RPG methodology from Microsoft Research. The key insight: separate WHAT (functional) from HOW (structural), then connect them with explicit dependencies.
-
-## Core Principles
-
-1. **Dual-Semantics**: Think functional (capabilities) AND structural (code organization) separately, then map them
-2. **Explicit Dependencies**: Never assume - always state what depends on what
-3. **Topological Order**: Build foundation first, then layers on top
-4. **Progressive Refinement**: Start broad, refine iteratively
-
-## How to Use This Template
-
-- Follow the instructions in each `<instruction>` block
-- Look at `<example>` blocks to see good vs bad patterns
-- Fill in the content sections with your project details
-- The AI reading this will learn the RPG method by following along
-- Task Master will parse the resulting PRD into dependency-aware tasks
-
-## Recommended Tools for Creating PRDs
-
-When using this template to **create** a PRD (not parse it), use **code-context-aware AI assistants** for best results:
-
-**Why?** The AI needs to understand your existing codebase to make good architectural decisions about modules, dependencies, and integration points.
-
-**Recommended tools:**
-- **Claude Code** (claude-code CLI) - Best for structured reasoning and large contexts
-- **Cursor/Windsurf** - IDE integration with full codebase context
-- **Gemini CLI** (gemini-cli) - Massive context window for large codebases
-- **Codex/Grok CLI** - Strong code generation with context awareness
-
-**Note:** Once your PRD is created, `task-master parse-prd` works with any configured AI model - it just needs to read the PRD text itself, not your codebase.
-</rpg-method>
-
----
-
-<overview>
-<instruction>
-Start with the problem, not the solution. Be specific about:
-- What pain point exists?
-- Who experiences it?
-- Why existing solutions don't work?
-- What success looks like (measurable outcomes)?
-
-Keep this section focused - don't jump into implementation details yet.
-</instruction>
-
-## Problem Statement
-[Describe the core problem. Be concrete about user pain points.]
-
-## Target Users
-[Define personas, their workflows, and what they're trying to achieve.]
-
-## Success Metrics
-[Quantifiable outcomes. Examples: "80% task completion via autopilot", "< 5% manual intervention rate"]
-
-</overview>
-
----
-
-<functional-decomposition>
-<instruction>
-Now think about CAPABILITIES (what the system DOES), not code structure yet.
-
-Step 1: Identify high-level capability domains
-- Think: "What major things does this system do?"
-- Examples: Data Management, Core Processing, Presentation Layer
-
-Step 2: For each capability, enumerate specific features
-- Use explore-exploit strategy:
-  * Exploit: What features are REQUIRED for core value?
-  * Explore: What features make this domain COMPLETE?
-
-Step 3: For each feature, define:
-- Description: What it does in one sentence
-- Inputs: What data/context it needs
-- Outputs: What it produces/returns
-- Behavior: Key logic or transformations
-
-<example type="good">
-Capability: Data Validation
-  Feature: Schema validation
-    - Description: Validate JSON payloads against defined schemas
-    - Inputs: JSON object, schema definition
-    - Outputs: Validation result (pass/fail) + error details
-    - Behavior: Iterate fields, check types, enforce constraints
-
-  Feature: Business rule validation
-    - Description: Apply domain-specific validation rules
-    - Inputs: Validated data object, rule set
-    - Outputs: Boolean + list of violated rules
-    - Behavior: Execute rules sequentially, short-circuit on failure
-</example>
-
-<example type="bad">
-Capability: validation.js
-  (Problem: This is a FILE, not a CAPABILITY. Mixing structure into functional thinking.)
-
-Capability: Validation
-  Feature: Make sure data is good
-  (Problem: Too vague. No inputs/outputs. Not actionable.)
-</example>
-</instruction>
-
-## Capability Tree
-
-### Capability: [Name]
-[Brief description of what this capability domain covers]
-
-#### Feature: [Name]
-- **Description**: [One sentence]
-- **Inputs**: [What it needs]
-- **Outputs**: [What it produces]
-- **Behavior**: [Key logic]
-
-#### Feature: [Name]
-- **Description**:
-- **Inputs**:
-- **Outputs**:
-- **Behavior**:
-
-### Capability: [Name]
-...
-
-</functional-decomposition>
-
----
-
-<structural-decomposition>
-<instruction>
-NOW think about code organization. Map capabilities to actual file/folder structure.
-
-Rules:
-1. Each capability maps to a module (folder or file)
-2. Features within a capability map to functions/classes
-3. Use clear module boundaries - each module has ONE responsibility
-4. Define what each module exports (public interface)
-
-The goal: Create a clear mapping between "what it does" (functional) and "where it lives" (structural).
-
-<example type="good">
-Capability: Data Validation
-  → Maps to: src/validation/
-    ├── schema-validator.js      (Schema validation feature)
-    ├── rule-validator.js         (Business rule validation feature)
-    └── index.js                  (Public exports)
-
-Exports:
-  - validateSchema(data, schema)
-  - validateRules(data, rules)
-</example>
-
-<example type="bad">
-Capability: Data Validation
-  → Maps to: src/utils.js
-  (Problem: "utils" is not a clear module boundary. Where do I find validation logic?)
-
-Capability: Data Validation
-  → Maps to: src/validation/everything.js
-  (Problem: One giant file. Features should map to separate files for maintainability.)
-</example>
-</instruction>
-
-## Repository Structure
-
-```
-project-root/
-├── src/
-│   ├── [module-name]/       # Maps to: [Capability Name]
-│   │   ├── [file].js        # Maps to: [Feature Name]
-│   │   └── index.js         # Public exports
-│   └── [module-name]/
-├── tests/
-└── docs/
-```
-
-## Module Definitions
-
-### Module: [Name]
-- **Maps to capability**: [Capability from functional decomposition]
-- **Responsibility**: [Single clear purpose]
-- **File structure**:
-  ```
-  module-name/
-  ├── feature1.js
-  ├── feature2.js
-  └── index.js
-  ```
-- **Exports**:
-  - `functionName()` - [what it does]
-  - `ClassName` - [what it does]
-
-</structural-decomposition>
-
----
-
-<dependency-graph>
-<instruction>
-This is THE CRITICAL SECTION for Task Master parsing.
-
-Define explicit dependencies between modules. This creates the topological order for task execution.
-
-Rules:
-1. List modules in dependency order (foundation first)
-2. For each module, state what it depends on
-3. Foundation modules should have NO dependencies
-4. Every non-foundation module should depend on at least one other module
-5. Think: "What must EXIST before I can build this module?"
-
-<example type="good">
-Foundation Layer (no dependencies):
-  - error-handling: No dependencies
-  - config-manager: No dependencies
-  - base-types: No dependencies
-
-Data Layer:
-  - schema-validator: Depends on [base-types, error-handling]
-  - data-ingestion: Depends on [schema-validator, config-manager]
-
-Core Layer:
-  - algorithm-engine: Depends on [base-types, error-handling]
-  - pipeline-orchestrator: Depends on [algorithm-engine, data-ingestion]
-</example>
-
-<example type="bad">
-- validation: Depends on API
-- API: Depends on validation
-(Problem: Circular dependency. This will cause build/runtime issues.)
-
-- user-auth: Depends on everything
-(Problem: Too many dependencies. Should be more focused.)
-</example>
-</instruction>
-
-## Dependency Chain
-
-### Foundation Layer (Phase 0)
-No dependencies - these are built first.
-
-- **[Module Name]**: [What it provides]
-- **[Module Name]**: [What it provides]
-
-### [Layer Name] (Phase 1)
-- **[Module Name]**: Depends on [[module-from-phase-0], [module-from-phase-0]]
-- **[Module Name]**: Depends on [[module-from-phase-0]]
-
-### [Layer Name] (Phase 2)
-- **[Module Name]**: Depends on [[module-from-phase-1], [module-from-foundation]]
-
-[Continue building up layers...]
-
-</dependency-graph>
-
----
-
-<implementation-roadmap>
-<instruction>
-Turn the dependency graph into concrete development phases.
-
-Each phase should:
-1. Have clear entry criteria (what must exist before starting)
-2. Contain tasks that can be parallelized (no inter-dependencies within phase)
-3. Have clear exit criteria (how do we know phase is complete?)
-4. Build toward something USABLE (not just infrastructure)
-
-Phase ordering follows topological sort of dependency graph.
-
-<example type="good">
-Phase 0: Foundation
-  Entry: Clean repository
-  Tasks:
-    - Implement error handling utilities
-    - Create base type definitions
-    - Setup configuration system
-  Exit: Other modules can import foundation without errors
-
-Phase 1: Data Layer
-  Entry: Phase 0 complete
-  Tasks:
-    - Implement schema validator (uses: base types, error handling)
-    - Build data ingestion pipeline (uses: validator, config)
-  Exit: End-to-end data flow from input to validated output
-</example>
-
-<example type="bad">
-Phase 1: Build Everything
-  Tasks:
-    - API
-    - Database
-    - UI
-    - Tests
-  (Problem: No clear focus. Too broad. Dependencies not considered.)
-</example>
-</instruction>
-
-## Development Phases
-
-### Phase 0: [Foundation Name]
-**Goal**: [What foundational capability this establishes]
-
-**Entry Criteria**: [What must be true before starting]
-
-**Tasks**:
-- [ ] [Task name] (depends on: [none or list])
-  - Acceptance criteria: [How we know it's done]
-  - Test strategy: [What tests prove it works]
-
-- [ ] [Task name] (depends on: [none or list])
-
-**Exit Criteria**: [Observable outcome that proves phase complete]
-
-**Delivers**: [What can users/developers do after this phase?]
-
----
-
-### Phase 1: [Layer Name]
-**Goal**:
-
-**Entry Criteria**: Phase 0 complete
-
-**Tasks**:
-- [ ] [Task name] (depends on: [[tasks-from-phase-0]])
-- [ ] [Task name] (depends on: [[tasks-from-phase-0]])
-
-**Exit Criteria**:
-
-**Delivers**:
-
----
-
-[Continue with more phases...]
-
-</implementation-roadmap>
-
----
-
-<test-strategy>
-<instruction>
-Define how testing will be integrated throughout development (TDD approach).
-
-Specify:
-1. Test pyramid ratios (unit vs integration vs e2e)
-2. Coverage requirements
-3. Critical test scenarios
-4. Test generation guidelines for Surgical Test Generator
-
-This section guides the AI when generating tests during the RED phase of TDD.
-
-<example type="good">
-Critical Test Scenarios for Data Validation module:
-  - Happy path: Valid data passes all checks
-  - Edge cases: Empty strings, null values, boundary numbers
-  - Error cases: Invalid types, missing required fields
-  - Integration: Validator works with ingestion pipeline
-</example>
-</instruction>
-
-## Test Pyramid
-
-```
-        /\
-       /E2E\       ← [X]% (End-to-end, slow, comprehensive)
-      /------\
-     /Integration\ ← [Y]% (Module interactions)
-    /------------\
-   /  Unit Tests  \ ← [Z]% (Fast, isolated, deterministic)
-  /----------------\
-```
-
-## Coverage Requirements
-- Line coverage: [X]% minimum
-- Branch coverage: [X]% minimum
-- Function coverage: [X]% minimum
-- Statement coverage: [X]% minimum
-
-## Critical Test Scenarios
-
-### [Module/Feature Name]
-**Happy path**:
-- [Scenario description]
-- Expected: [What should happen]
-
-**Edge cases**:
-- [Scenario description]
-- Expected: [What should happen]
-
-**Error cases**:
-- [Scenario description]
-- Expected: [How system handles failure]
-
-**Integration points**:
-- [What interactions to test]
-- Expected: [End-to-end behavior]
-
-## Test Generation Guidelines
-[Specific instructions for Surgical Test Generator about what to focus on, what patterns to follow, project-specific test conventions]
-
-</test-strategy>
-
----
-
-<architecture>
-<instruction>
-Describe technical architecture, data models, and key design decisions.
-
-Keep this section AFTER functional/structural decomposition - implementation details come after understanding structure.
-</instruction>
-
-## System Components
-[Major architectural pieces and their responsibilities]
-
-## Data Models
-[Core data structures, schemas, database design]
-
-## Technology Stack
-[Languages, frameworks, key libraries]
-
-**Decision: [Technology/Pattern]**
-- **Rationale**: [Why chosen]
-- **Trade-offs**: [What we're giving up]
-- **Alternatives considered**: [What else we looked at]
-
-</architecture>
-
----
-
-<risks>
-<instruction>
-Identify risks that could derail development and how to mitigate them.
-
-Categories:
-- Technical risks (complexity, unknowns)
-- Dependency risks (blocking issues)
-- Scope risks (creep, underestimation)
-</instruction>
-
-## Technical Risks
-**Risk**: [Description]
-- **Impact**: [High/Medium/Low - effect on project]
-- **Likelihood**: [High/Medium/Low]
-- **Mitigation**: [How to address]
-- **Fallback**: [Plan B if mitigation fails]
-
-## Dependency Risks
-[External dependencies, blocking issues]
-
-## Scope Risks
-[Scope creep, underestimation, unclear requirements]
-
-</risks>
-
----
-
-<appendix>
-## References
-[Papers, documentation, similar systems]
-
-## Glossary
-[Domain-specific terms]
-
-## Open Questions
-[Things to resolve during development]
-</appendix>
-
----
-
-<task-master-integration>
-# How Task Master Uses This PRD
-
-When you run `task-master parse-prd <file>.txt`, the parser:
-
-1. **Extracts capabilities** → Main tasks
-   - Each `### Capability:` becomes a top-level task
-
-2. **Extracts features** → Subtasks
-   - Each `#### Feature:` becomes a subtask under its capability
-
-3. **Parses dependencies** → Task dependencies
-   - `Depends on: [X, Y]` sets task.dependencies = ["X", "Y"]
-
-4. **Orders by phases** → Task priorities
-   - Phase 0 tasks = highest priority
-   - Phase N tasks = lower priority, properly sequenced
-
-5. **Uses test strategy** → Test generation context
-   - Feeds test scenarios to Surgical Test Generator during implementation
-
-**Result**: A dependency-aware task graph that can be executed in topological order.
-
-## Why RPG Structure Matters
-
-Traditional flat PRDs lead to:
-- ❌ Unclear task dependencies
-- ❌ Arbitrary task ordering
-- ❌ Circular dependencies discovered late
-- ❌ Poorly scoped tasks
-
-RPG-structured PRDs provide:
-- ✅ Explicit dependency chains
-- ✅ Topological execution order
-- ✅ Clear module boundaries
-- ✅ Validated task graph before implementation
-
-## Tips for Best Results
-
-1. **Spend time on dependency graph** - This is the most valuable section for Task Master
-2. **Keep features atomic** - Each feature should be independently testable
-3. **Progressive refinement** - Start broad, use `task-master expand` to break down complex tasks
-4. **Use research mode** - `task-master parse-prd --research` leverages AI for better task generation
-</task-master-integration>

CHANGELOG.md

@@ -1,350 +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
-
-- [#1273](https://github.com/eyaltoledano/claude-task-master/pull/1273) [`b43b7ce`](https://github.com/eyaltoledano/claude-task-master/commit/b43b7ce201625eee956fb2f8cd332f238bb78c21) Thanks [@ben-vargas](https://github.com/ben-vargas)! - Add Codex CLI provider with OAuth authentication
-  - Added codex-cli provider for GPT-5 and GPT-5-Codex models (272K input / 128K output)
-  - OAuth-first authentication via `codex login` - no API key required
-  - Optional OPENAI_CODEX_API_KEY support
-  - Codebase analysis capabilities automatically enabled
-  - Command-specific settings and approval/sandbox modes
-
-- [#1215](https://github.com/eyaltoledano/claude-task-master/pull/1215) [`0079b7d`](https://github.com/eyaltoledano/claude-task-master/commit/0079b7defdad550811f704c470fdd01955d91d4d) Thanks [@joedanz](https://github.com/joedanz)! - Add Cursor IDE custom slash command support
-
-  Expose Task Master commands as Cursor slash commands by copying assets/claude/commands to .cursor/commands on profile add and cleaning up on remove.
-
-- [#1246](https://github.com/eyaltoledano/claude-task-master/pull/1246) [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Added api keys page on docs website: docs.task-master.dev/getting-started/api-keys
-
-- [#1246](https://github.com/eyaltoledano/claude-task-master/pull/1246) [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Move to AI SDK v5:
-  - Works better with claude-code and gemini-cli as ai providers
-  - Improved openai model family compatibility
-  - Migrate ollama provider to v2
-  - Closes #1223, #1013, #1161, #1174
-
-- [#1262](https://github.com/eyaltoledano/claude-task-master/pull/1262) [`738ec51`](https://github.com/eyaltoledano/claude-task-master/commit/738ec51c049a295a12839b2dfddaf05e23b8fede) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Migrate AI services to use generateObject for structured data generation
-
-  This update migrates all AI service calls from generateText to generateObject, ensuring more reliable and structured responses across all commands.
-
-  ### Key Changes:
-  - **Unified AI Service**: Replaced separate generateText implementations with a single generateObjectService that handles structured data generation
-  - **JSON Mode Support**: Added proper JSON mode configuration for providers that support it (OpenAI, Anthropic, Google, Groq)
-  - **Schema Validation**: Integrated Zod schemas for all AI-generated content with automatic validation
-  - **Provider Compatibility**: Maintained compatibility with all existing providers while leveraging their native structured output capabilities
-  - **Improved Reliability**: Structured output generation reduces parsing errors and ensures consistent data formats
-
-  ### Technical Improvements:
-  - Centralized provider configuration in `ai-providers-unified.js`
-  - Added `generateObject` support detection for each provider
-  - Implemented proper error handling for schema validation failures
-  - Maintained backward compatibility with existing prompt structures
-
-  ### Bug Fixes:
-  - Fixed subtask ID numbering issue where AI was generating inconsistent IDs (101-105, 601-603) instead of sequential numbering (1, 2, 3...)
-  - Enhanced prompt instructions to enforce proper ID generation patterns
-  - Ensured subtasks display correctly as X.1, X.2, X.3 format
-
-  This migration improves the reliability and consistency of AI-generated content throughout the Task Master application.
-
-- [#1112](https://github.com/eyaltoledano/claude-task-master/pull/1112) [`d67b81d`](https://github.com/eyaltoledano/claude-task-master/commit/d67b81d25ddd927fabb6f5deb368e8993519c541) Thanks [@olssonsten](https://github.com/olssonsten)! - Enhanced Roo Code profile with MCP timeout configuration for improved reliability during long-running AI operations. The Roo profile now automatically configures a 300-second timeout for MCP server operations, preventing timeouts during complex tasks like `parse-prd`, `expand-all`, `analyze-complexity`, and `research` operations. This change also replaces static MCP configuration files with programmatic generation for better maintainability.
-
-  **What's New:**
-  - 300-second timeout for MCP operations (up from default 60 seconds)
-  - Programmatic MCP configuration generation (replaces static asset files)
-  - Enhanced reliability for AI-powered operations
-  - Consistent with other AI coding assistant profiles
-
-  **Migration:** No user action required - existing Roo Code installations will automatically receive the enhanced MCP configuration on next initialization.
-
-- [#1246](https://github.com/eyaltoledano/claude-task-master/pull/1246) [`986ac11`](https://github.com/eyaltoledano/claude-task-master/commit/986ac117aee00bcd3e6830a0f76e1ad6d10e0bca) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Upgrade grok-cli ai provider to ai sdk v5
-
-### Patch Changes
-
-- [#1235](https://github.com/eyaltoledano/claude-task-master/pull/1235) [`aaacc3d`](https://github.com/eyaltoledano/claude-task-master/commit/aaacc3dae36247b4de72b2d2697f49e5df6d01e3) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve `analyze-complexity` cli docs and `--research` flag documentation
-
-- [#1251](https://github.com/eyaltoledano/claude-task-master/pull/1251) [`0b2c696`](https://github.com/eyaltoledano/claude-task-master/commit/0b2c6967c4605c33a100cff16f6ce8ff09ad06f0) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Change parent task back to "pending" when all subtasks are in "pending" state
-
-- [#1274](https://github.com/eyaltoledano/claude-task-master/pull/1274) [`4f984f8`](https://github.com/eyaltoledano/claude-task-master/commit/4f984f8a6965da9f9c7edd60ddfd6560ac022917) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Do a quick fix on build
-
-- [#1277](https://github.com/eyaltoledano/claude-task-master/pull/1277) [`7b5a7c4`](https://github.com/eyaltoledano/claude-task-master/commit/7b5a7c4495a68b782f7407fc5d0e0d3ae81f42f5) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix MCP connection errors caused by deprecated generateTaskFiles calls. Resolves "Cannot read properties of null (reading 'toString')" errors when using MCP tools for task management operations.
-
-- [#1276](https://github.com/eyaltoledano/claude-task-master/pull/1276) [`caee040`](https://github.com/eyaltoledano/claude-task-master/commit/caee040907f856d31a660171c9e6d966f23c632e) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix MCP server error when file parameter not provided - now properly constructs default tasks.json path instead of failing with 'tasksJsonPath is required' error.
-
-- [#1172](https://github.com/eyaltoledano/claude-task-master/pull/1172) [`b5fe723`](https://github.com/eyaltoledano/claude-task-master/commit/b5fe723f8ead928e9f2dbde13b833ee70ac3382d) Thanks [@jujax](https://github.com/jujax)! - Fix Claude Code settings validation for pathToClaudeCodeExecutable
-
-- [#1192](https://github.com/eyaltoledano/claude-task-master/pull/1192) [`2b69936`](https://github.com/eyaltoledano/claude-task-master/commit/2b69936ee7b34346d6de5175af20e077359e2e2a) Thanks [@nukunga](https://github.com/nukunga)! - Fix sonar deep research model failing, should be called `sonar-deep-research`
-
-- [#1270](https://github.com/eyaltoledano/claude-task-master/pull/1270) [`20004a3`](https://github.com/eyaltoledano/claude-task-master/commit/20004a39ea848f747e1ff48981bfe176554e4055) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix complexity score not showing for `task-master show` and `task-master list`
-  - Added complexity score on "next task" when running `task-master list`
-  - Added colors to complexity to reflect complexity (easy, medium, hard)
-
-## 0.28.0-rc.2
-
-### Minor Changes
-
-- [#1273](https://github.com/eyaltoledano/claude-task-master/pull/1273) [`b43b7ce`](https://github.com/eyaltoledano/claude-task-master/commit/b43b7ce201625eee956fb2f8cd332f238bb78c21) Thanks [@ben-vargas](https://github.com/ben-vargas)! - Add Codex CLI provider with OAuth authentication
-  - Added codex-cli provider for GPT-5 and GPT-5-Codex models (272K input / 128K output)
-  - OAuth-first authentication via `codex login` - no API key required
-  - Optional OPENAI_CODEX_API_KEY support
-  - Codebase analysis capabilities automatically enabled
-  - Command-specific settings and approval/sandbox modes
-
-### Patch Changes
-
-- [#1277](https://github.com/eyaltoledano/claude-task-master/pull/1277) [`7b5a7c4`](https://github.com/eyaltoledano/claude-task-master/commit/7b5a7c4495a68b782f7407fc5d0e0d3ae81f42f5) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix MCP connection errors caused by deprecated generateTaskFiles calls. Resolves "Cannot read properties of null (reading 'toString')" errors when using MCP tools for task management operations.
-
-- [#1276](https://github.com/eyaltoledano/claude-task-master/pull/1276) [`caee040`](https://github.com/eyaltoledano/claude-task-master/commit/caee040907f856d31a660171c9e6d966f23c632e) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix MCP server error when file parameter not provided - now properly constructs default tasks.json path instead of failing with 'tasksJsonPath is required' error.
-
-## 0.28.0-rc.1
-
-### Patch Changes
-
-- [#1274](https://github.com/eyaltoledano/claude-task-master/pull/1274) [`4f984f8`](https://github.com/eyaltoledano/claude-task-master/commit/4f984f8a6965da9f9c7edd60ddfd6560ac022917) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Do a quick fix on build
-
-## 0.28.0-rc.0
-
-### Minor Changes
-
-- [#1215](https://github.com/eyaltoledano/claude-task-master/pull/1215) [`0079b7d`](https://github.com/eyaltoledano/claude-task-master/commit/0079b7defdad550811f704c470fdd01955d91d4d) Thanks [@joedanz](https://github.com/joedanz)! - Add Cursor IDE custom slash command support
-
-  Expose Task Master commands as Cursor slash commands by copying assets/claude/commands to .cursor/commands on profile add and cleaning up on remove.
-
-- [#1246](https://github.com/eyaltoledano/claude-task-master/pull/1246) [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Added api keys page on docs website: docs.task-master.dev/getting-started/api-keys
-
-- [#1246](https://github.com/eyaltoledano/claude-task-master/pull/1246) [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Move to AI SDK v5:
-  - Works better with claude-code and gemini-cli as ai providers
-  - Improved openai model family compatibility
-  - Migrate ollama provider to v2
-  - Closes #1223, #1013, #1161, #1174
-
-- [#1262](https://github.com/eyaltoledano/claude-task-master/pull/1262) [`738ec51`](https://github.com/eyaltoledano/claude-task-master/commit/738ec51c049a295a12839b2dfddaf05e23b8fede) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Migrate AI services to use generateObject for structured data generation
-
-  This update migrates all AI service calls from generateText to generateObject, ensuring more reliable and structured responses across all commands.
-
-  ### Key Changes:
-  - **Unified AI Service**: Replaced separate generateText implementations with a single generateObjectService that handles structured data generation
-  - **JSON Mode Support**: Added proper JSON mode configuration for providers that support it (OpenAI, Anthropic, Google, Groq)
-  - **Schema Validation**: Integrated Zod schemas for all AI-generated content with automatic validation
-  - **Provider Compatibility**: Maintained compatibility with all existing providers while leveraging their native structured output capabilities
-  - **Improved Reliability**: Structured output generation reduces parsing errors and ensures consistent data formats
-
-  ### Technical Improvements:
-  - Centralized provider configuration in `ai-providers-unified.js`
-  - Added `generateObject` support detection for each provider
-  - Implemented proper error handling for schema validation failures
-  - Maintained backward compatibility with existing prompt structures
-
-  ### Bug Fixes:
-  - Fixed subtask ID numbering issue where AI was generating inconsistent IDs (101-105, 601-603) instead of sequential numbering (1, 2, 3...)
-  - Enhanced prompt instructions to enforce proper ID generation patterns
-  - Ensured subtasks display correctly as X.1, X.2, X.3 format
-
-  This migration improves the reliability and consistency of AI-generated content throughout the Task Master application.
-
-- [#1112](https://github.com/eyaltoledano/claude-task-master/pull/1112) [`d67b81d`](https://github.com/eyaltoledano/claude-task-master/commit/d67b81d25ddd927fabb6f5deb368e8993519c541) Thanks [@olssonsten](https://github.com/olssonsten)! - Enhanced Roo Code profile with MCP timeout configuration for improved reliability during long-running AI operations. The Roo profile now automatically configures a 300-second timeout for MCP server operations, preventing timeouts during complex tasks like `parse-prd`, `expand-all`, `analyze-complexity`, and `research` operations. This change also replaces static MCP configuration files with programmatic generation for better maintainability.
-
-  **What's New:**
-  - 300-second timeout for MCP operations (up from default 60 seconds)
-  - Programmatic MCP configuration generation (replaces static asset files)
-  - Enhanced reliability for AI-powered operations
-  - Consistent with other AI coding assistant profiles
-
-  **Migration:** No user action required - existing Roo Code installations will automatically receive the enhanced MCP configuration on next initialization.
-
-- [#1246](https://github.com/eyaltoledano/claude-task-master/pull/1246) [`986ac11`](https://github.com/eyaltoledano/claude-task-master/commit/986ac117aee00bcd3e6830a0f76e1ad6d10e0bca) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Upgrade grok-cli ai provider to ai sdk v5
-
-### Patch Changes
-
-- [#1235](https://github.com/eyaltoledano/claude-task-master/pull/1235) [`aaacc3d`](https://github.com/eyaltoledano/claude-task-master/commit/aaacc3dae36247b4de72b2d2697f49e5df6d01e3) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve `analyze-complexity` cli docs and `--research` flag documentation
-
-- [#1251](https://github.com/eyaltoledano/claude-task-master/pull/1251) [`0b2c696`](https://github.com/eyaltoledano/claude-task-master/commit/0b2c6967c4605c33a100cff16f6ce8ff09ad06f0) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Change parent task back to "pending" when all subtasks are in "pending" state
-
-- [#1172](https://github.com/eyaltoledano/claude-task-master/pull/1172) [`b5fe723`](https://github.com/eyaltoledano/claude-task-master/commit/b5fe723f8ead928e9f2dbde13b833ee70ac3382d) Thanks [@jujax](https://github.com/jujax)! - Fix Claude Code settings validation for pathToClaudeCodeExecutable
-
-- [#1192](https://github.com/eyaltoledano/claude-task-master/pull/1192) [`2b69936`](https://github.com/eyaltoledano/claude-task-master/commit/2b69936ee7b34346d6de5175af20e077359e2e2a) Thanks [@nukunga](https://github.com/nukunga)! - Fix sonar deep research model failing, should be called `sonar-deep-research`
-
-- [#1270](https://github.com/eyaltoledano/claude-task-master/pull/1270) [`20004a3`](https://github.com/eyaltoledano/claude-task-master/commit/20004a39ea848f747e1ff48981bfe176554e4055) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix complexity score not showing for `task-master show` and `task-master list`
-  - Added complexity score on "next task" when running `task-master list`
-  - Added colors to complexity to reflect complexity (easy, medium, hard)
-
-## 0.27.3
-
-### Patch Changes
-
-- [#1254](https://github.com/eyaltoledano/claude-task-master/pull/1254) [`af53525`](https://github.com/eyaltoledano/claude-task-master/commit/af53525cbc660a595b67d4bb90d906911c71f45d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fixed issue where `tm show` command could not find subtasks using dotted notation IDs (e.g., '8.1').
-  - The command now properly searches within parent task subtasks and returns the correct subtask information.
-
 ## 0.27.2
 
 ### Patch Changes

CLAUDE.md

@@ -4,28 +4,6 @@
 **Import Task Master's development workflow commands and guidelines, treat as if import is in the main CLAUDE.md file.**
 @./.taskmaster/CLAUDE.md
 
-## Test Guidelines
-
-### Synchronous Tests
-- **NEVER use async/await in test functions** unless testing actual asynchronous operations
-- Use synchronous top-level imports instead of dynamic `await import()`
-- Test bodies should be synchronous whenever possible
-- Example:
-  ```javascript
-  // ✅ CORRECT - Synchronous imports
-  import { MyClass } from '../src/my-class.js';
-
-  it('should verify behavior', () => {
-    expect(new MyClass().property).toBe(value);
-  });
-
-  // ❌ INCORRECT - Async imports
-  it('should verify behavior', async () => {
-    const { MyClass } = await import('../src/my-class.js');
-    expect(new MyClass().property).toBe(value);
-  });
-  ```
-
 ## Changeset Guidelines
 
 - When creating changesets, remember that it's user-facing, meaning we don't have to get into the specifics of the code, but rather mention what the end-user is getting or fixing from this changeset.

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

@@ -88,9 +88,8 @@ At least one (1) of the following is required:
 - xAI API Key (for research or main model)
 - OpenRouter API Key (for research or main model)
 - Claude Code (no API key required - requires Claude Code CLI)
-- Codex CLI (OAuth via ChatGPT subscription - requires Codex CLI)
 
-Using the research model is optional but highly recommended. You will need at least ONE API key (unless using Claude Code or Codex CLI with OAuth). Adding all API keys enables you to seamlessly switch between model providers at will.
+Using the research model is optional but highly recommended. You will need at least ONE API key (unless using Claude Code). Adding all API keys enables you to seamlessly switch between model providers at will.
 
 ## Quick Start
 
@@ -310,12 +309,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

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

apps/cli/package.json

@@ -35,7 +35,7 @@
 		"@types/inquirer": "^9.0.3",
 		"@types/node": "^22.10.5",
 		"tsx": "^4.20.4",
-		"typescript": "^5.9.2",
+		"typescript": "^5.7.3",
 		"vitest": "^2.1.8"
 	},
 	"engines": {
@@ -48,6 +48,5 @@
 		"*": {
 			"*": ["src/*"]
 		}
-	},
+	}
-	"version": ""
 }

apps/cli/src/command-registry.ts

@@ -1,255 +0,0 @@
-/**
- * @fileoverview Centralized Command Registry
- * Provides a single location for registering all CLI commands
- */
-
-import { Command } from 'commander';
-
-// Import all commands
-import { ListTasksCommand } from './commands/list.command.js';
-import { ShowCommand } from './commands/show.command.js';
-import { AuthCommand } from './commands/auth.command.js';
-import { ContextCommand } from './commands/context.command.js';
-import { StartCommand } from './commands/start.command.js';
-import { SetStatusCommand } from './commands/set-status.command.js';
-import { ExportCommand } from './commands/export.command.js';
-
-/**
- * Command metadata for registration
- */
-export interface CommandMetadata {
-	name: string;
-	description: string;
-	commandClass: typeof Command;
-	category?: 'task' | 'auth' | 'utility' | 'development';
-}
-
-/**
- * Registry of all available commands
- */
-export class CommandRegistry {
-	/**
-	 * All available commands with their metadata
-	 */
-	private static commands: CommandMetadata[] = [
-		// Task Management Commands
-		{
-			name: 'list',
-			description: 'List all tasks with filtering and status overview',
-			commandClass: ListTasksCommand as any,
-			category: 'task'
-		},
-		{
-			name: 'show',
-			description: 'Display detailed information about a specific task',
-			commandClass: ShowCommand as any,
-			category: 'task'
-		},
-		{
-			name: 'start',
-			description: 'Start working on a task with claude-code',
-			commandClass: StartCommand as any,
-			category: 'task'
-		},
-		{
-			name: 'set-status',
-			description: 'Update the status of one or more tasks',
-			commandClass: SetStatusCommand as any,
-			category: 'task'
-		},
-		{
-			name: 'export',
-			description: 'Export tasks to external systems',
-			commandClass: ExportCommand as any,
-			category: 'task'
-		},
-
-		// Authentication & Context Commands
-		{
-			name: 'auth',
-			description: 'Manage authentication with tryhamster.com',
-			commandClass: AuthCommand as any,
-			category: 'auth'
-		},
-		{
-			name: 'context',
-			description: 'Manage workspace context (organization/brief)',
-			commandClass: ContextCommand as any,
-			category: 'auth'
-		}
-	];
-
-	/**
-	 * Register all commands on a program instance
-	 * @param program - Commander program to register commands on
-	 */
-	static registerAll(program: Command): void {
-		for (const cmd of this.commands) {
-			this.registerCommand(program, cmd);
-		}
-	}
-
-	/**
-	 * Register specific commands by category
-	 * @param program - Commander program to register commands on
-	 * @param category - Category of commands to register
-	 */
-	static registerByCategory(
-		program: Command,
-		category: 'task' | 'auth' | 'utility' | 'development'
-	): void {
-		const categoryCommands = this.commands.filter(
-			(cmd) => cmd.category === category
-		);
-
-		for (const cmd of categoryCommands) {
-			this.registerCommand(program, cmd);
-		}
-	}
-
-	/**
-	 * Register a single command by name
-	 * @param program - Commander program to register the command on
-	 * @param name - Name of the command to register
-	 */
-	static registerByName(program: Command, name: string): void {
-		const cmd = this.commands.find((c) => c.name === name);
-		if (cmd) {
-			this.registerCommand(program, cmd);
-		} else {
-			throw new Error(`Command '${name}' not found in registry`);
-		}
-	}
-
-	/**
-	 * Register a single command
-	 * @param program - Commander program to register the command on
-	 * @param metadata - Command metadata
-	 */
-	private static registerCommand(
-		program: Command,
-		metadata: CommandMetadata
-	): void {
-		const CommandClass = metadata.commandClass as any;
-
-		// Use the static registration method that all commands have
-		if (CommandClass.registerOn) {
-			CommandClass.registerOn(program);
-		} else if (CommandClass.register) {
-			CommandClass.register(program);
-		} else {
-			// Fallback to creating instance and adding
-			const instance = new CommandClass();
-			program.addCommand(instance);
-		}
-	}
-
-	/**
-	 * Get all registered command names
-	 */
-	static getCommandNames(): string[] {
-		return this.commands.map((cmd) => cmd.name);
-	}
-
-	/**
-	 * Get commands by category
-	 */
-	static getCommandsByCategory(
-		category: 'task' | 'auth' | 'utility' | 'development'
-	): CommandMetadata[] {
-		return this.commands.filter((cmd) => cmd.category === category);
-	}
-
-	/**
-	 * Add a new command to the registry
-	 * @param metadata - Command metadata to add
-	 */
-	static addCommand(metadata: CommandMetadata): void {
-		// Check if command already exists
-		if (this.commands.some((cmd) => cmd.name === metadata.name)) {
-			throw new Error(`Command '${metadata.name}' already exists in registry`);
-		}
-
-		this.commands.push(metadata);
-	}
-
-	/**
-	 * Remove a command from the registry
-	 * @param name - Name of the command to remove
-	 */
-	static removeCommand(name: string): boolean {
-		const index = this.commands.findIndex((cmd) => cmd.name === name);
-		if (index >= 0) {
-			this.commands.splice(index, 1);
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Get command metadata by name
-	 * @param name - Name of the command
-	 */
-	static getCommand(name: string): CommandMetadata | undefined {
-		return this.commands.find((cmd) => cmd.name === name);
-	}
-
-	/**
-	 * Check if a command exists
-	 * @param name - Name of the command
-	 */
-	static hasCommand(name: string): boolean {
-		return this.commands.some((cmd) => cmd.name === name);
-	}
-
-	/**
-	 * Get a formatted list of all commands for display
-	 */
-	static getFormattedCommandList(): string {
-		const categories = {
-			task: 'Task Management',
-			auth: 'Authentication & Context',
-			utility: 'Utilities',
-			development: 'Development'
-		};
-
-		let output = '';
-
-		for (const [category, title] of Object.entries(categories)) {
-			const cmds = this.getCommandsByCategory(
-				category as keyof typeof categories
-			);
-			if (cmds.length > 0) {
-				output += `\n${title}:\n`;
-				for (const cmd of cmds) {
-					output += `  ${cmd.name.padEnd(20)} ${cmd.description}\n`;
-				}
-			}
-		}
-
-		return output;
-	}
-}
-
-/**
- * Convenience function to register all CLI commands
- * @param program - Commander program instance
- */
-export function registerAllCommands(program: Command): void {
-	CommandRegistry.registerAll(program);
-}
-
-/**
- * Convenience function to register commands by category
- * @param program - Commander program instance
- * @param category - Category to register
- */
-export function registerCommandsByCategory(
-	program: Command,
-	category: 'task' | 'auth' | 'utility' | 'development'
-): void {
-	CommandRegistry.registerByCategory(program, category);
-}
-
-// Export the registry for direct access if needed
-export default CommandRegistry;

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

@@ -143,7 +143,7 @@ export class AuthCommand extends Command {
 	 */
 	private async executeStatus(): Promise<void> {
 		try {
-			const result = await this.displayStatus();
+			const result = this.displayStatus();
 			this.setLastResult(result);
 		} catch (error: any) {
 			this.handleError(error);
@@ -171,8 +171,8 @@ export class AuthCommand extends Command {
 	/**
 	 * Display authentication status
 	 */
-	private async displayStatus(): Promise<AuthResult> {
+	private displayStatus(): AuthResult {
-		const credentials = await this.authManager.getCredentials();
+		const credentials = this.authManager.getCredentials();
 
 		console.log(chalk.cyan('\n🔐 Authentication Status\n'));
 
@@ -187,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(
-				const hoursRemaining = Math.floor(timeRemaining / (1000 * 60 * 60));
+					(expiresAt.getTime() - now.getTime()) / (1000 * 60 * 60)
-				const minutesRemaining = Math.floor(timeRemaining / (1000 * 60));
+				);
 
-				if (timeRemaining > 0) {
+				if (hoursRemaining > 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
 					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 {
@@ -325,7 +315,7 @@ export class AuthCommand extends Command {
 			]);
 
 			if (!continueAuth) {
-				const credentials = await this.authManager.getCredentials();
+				const credentials = this.authManager.getCredentials();
 				ui.displaySuccess('Using existing authentication');
 
 				if (credentials) {
@@ -490,7 +480,7 @@ export class AuthCommand extends Command {
 	/**
 	 * Get current credentials (for programmatic usage)
 	 */
-	getCredentials(): Promise<AuthCredentials | null> {
+	getCredentials(): AuthCredentials | null {
 		return this.authManager.getCredentials();
 	}
 
@@ -503,7 +493,18 @@ export class AuthCommand extends Command {
 	}
 
 	/**
-	 * Register this command on an existing program
+	 * Static method to register this command on an existing program
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const authCommand = new AuthCommand();
+		program.addCommand(authCommand);
+		return authCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
 	 */
 	static register(program: Command, name?: string): AuthCommand {
 		const authCommand = new AuthCommand(name);

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

@@ -115,7 +115,7 @@ export class ContextCommand extends Command {
 	 */
 	private async executeShow(): Promise<void> {
 		try {
-			const result = await this.displayContext();
+			const result = this.displayContext();
 			this.setLastResult(result);
 		} catch (error: any) {
 			this.handleError(error);
@@ -126,7 +126,7 @@ export class ContextCommand extends Command {
 	/**
 	 * Display current context
 	 */
-	private async displayContext(): Promise<ContextResult> {
+	private displayContext(): ContextResult {
 		// Check authentication first
 		if (!this.authManager.isAuthenticated()) {
 			console.log(chalk.yellow('✗ Not authenticated'));
@@ -139,7 +139,7 @@ export class ContextCommand extends Command {
 			};
 		}
 
-		const context = await this.authManager.getContext();
+		const context = this.authManager.getContext();
 
 		console.log(chalk.cyan('\n🌍 Workspace Context\n'));
 
@@ -263,7 +263,7 @@ export class ContextCommand extends Command {
 			return {
 				success: true,
 				action: 'select-org',
-				context: (await this.authManager.getContext()) || undefined,
+				context: this.authManager.getContext() || undefined,
 				message: `Selected organization: ${selectedOrg.name}`
 			};
 		} catch (error) {
@@ -284,7 +284,7 @@ export class ContextCommand extends Command {
 			}
 
 			// Check if org is selected
-			const context = await this.authManager.getContext();
+			const context = this.authManager.getContext();
 			if (!context?.orgId) {
 				ui.displayError(
 					'No organization selected. Run "tm context org" first.'
@@ -353,7 +353,7 @@ export class ContextCommand extends Command {
 				return {
 					success: true,
 					action: 'select-brief',
-					context: (await this.authManager.getContext()) || undefined,
+					context: this.authManager.getContext() || undefined,
 					message: `Selected brief: ${selectedBrief.name}`
 				};
 			} else {
@@ -368,7 +368,7 @@ export class ContextCommand extends Command {
 				return {
 					success: true,
 					action: 'select-brief',
-					context: (await this.authManager.getContext()) || undefined,
+					context: this.authManager.getContext() || undefined,
 					message: 'Cleared brief selection'
 				};
 			}
@@ -508,7 +508,7 @@ export class ContextCommand extends Command {
 			this.setLastResult({
 				success: true,
 				action: 'set',
-				context: (await this.authManager.getContext()) || undefined,
+				context: this.authManager.getContext() || undefined,
 				message: 'Context set from brief'
 			});
 		} catch (error: any) {
@@ -631,7 +631,7 @@ export class ContextCommand extends Command {
 			return {
 				success: true,
 				action: 'set',
-				context: (await this.authManager.getContext()) || undefined,
+				context: this.authManager.getContext() || undefined,
 				message: 'Context updated'
 			};
 		} catch (error) {
@@ -682,7 +682,7 @@ export class ContextCommand extends Command {
 	/**
 	 * Get current context (for programmatic usage)
 	 */
-	getContext(): Promise<UserContext | null> {
+	getContext(): UserContext | null {
 		return this.authManager.getContext();
 	}
 
@@ -694,7 +694,16 @@ export class ContextCommand extends Command {
 	}
 
 	/**
-	 * Register this command on an existing program
+	 * Static method to register this command on an existing program
+	 */
+	static registerOn(program: Command): Command {
+		const contextCommand = new ContextCommand();
+		program.addCommand(contextCommand);
+		return contextCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
 	 */
 	static register(program: Command, name?: string): ContextCommand {
 		const contextCommand = new ContextCommand(name);

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

@@ -1,379 +0,0 @@
-/**
- * @fileoverview Export command for exporting tasks to external systems
- * Provides functionality to export tasks to Hamster briefs
- */
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import ora, { Ora } from 'ora';
-import {
-	AuthManager,
-	AuthenticationError,
-	type UserContext
-} from '@tm/core/auth';
-import { TaskMasterCore, type ExportResult } from '@tm/core';
-import * as ui from '../utils/ui.js';
-
-/**
- * Result type from export command
- */
-export interface ExportCommandResult {
-	success: boolean;
-	action: 'export' | 'validate' | 'cancelled';
-	result?: ExportResult;
-	message?: string;
-}
-
-/**
- * ExportCommand extending Commander's Command class
- * Handles task export to external systems
- */
-export class ExportCommand extends Command {
-	private authManager: AuthManager;
-	private taskMasterCore?: TaskMasterCore;
-	private lastResult?: ExportCommandResult;
-
-	constructor(name?: string) {
-		super(name || 'export');
-
-		// Initialize auth manager
-		this.authManager = AuthManager.getInstance();
-
-		// Configure the command
-		this.description('Export tasks to external systems (e.g., Hamster briefs)');
-
-		// Add options
-		this.option('--org <id>', 'Organization ID to export to');
-		this.option('--brief <id>', 'Brief ID to export tasks to');
-		this.option('--tag <tag>', 'Export tasks from a specific tag');
-		this.option(
-			'--status <status>',
-			'Filter tasks by status (pending, in-progress, done, etc.)'
-		);
-		this.option('--exclude-subtasks', 'Exclude subtasks from export');
-		this.option('-y, --yes', 'Skip confirmation prompt');
-
-		// Accept optional positional argument for brief ID or Hamster URL
-		this.argument('[briefOrUrl]', 'Brief ID or Hamster brief URL');
-
-		// Default action
-		this.action(async (briefOrUrl?: string, options?: any) => {
-			await this.executeExport(briefOrUrl, options);
-		});
-	}
-
-	/**
-	 * Initialize the TaskMasterCore
-	 */
-	private async initializeServices(): Promise<void> {
-		if (this.taskMasterCore) {
-			return;
-		}
-
-		try {
-			// Initialize TaskMasterCore
-			this.taskMasterCore = await TaskMasterCore.create({
-				projectPath: process.cwd()
-			});
-		} catch (error) {
-			throw new Error(
-				`Failed to initialize services: ${(error as Error).message}`
-			);
-		}
-	}
-
-	/**
-	 * Execute the export command
-	 */
-	private async executeExport(
-		briefOrUrl?: string,
-		options?: any
-	): Promise<void> {
-		let spinner: Ora | undefined;
-
-		try {
-			// Check authentication
-			if (!this.authManager.isAuthenticated()) {
-				ui.displayError('Not authenticated. Run "tm auth login" first.');
-				process.exit(1);
-			}
-
-			// Initialize services
-			await this.initializeServices();
-
-			// Get current context
-			const context = await this.authManager.getContext();
-
-			// Determine org and brief IDs
-			let orgId = options?.org || context?.orgId;
-			let briefId = options?.brief || briefOrUrl || context?.briefId;
-
-			// If a URL/ID was provided as argument, resolve it
-			if (briefOrUrl && !options?.brief) {
-				spinner = ora('Resolving brief...').start();
-				const resolvedBrief = await this.resolveBriefInput(briefOrUrl);
-				if (resolvedBrief) {
-					briefId = resolvedBrief.briefId;
-					orgId = resolvedBrief.orgId;
-					spinner.succeed('Brief resolved');
-				} else {
-					spinner.fail('Could not resolve brief');
-					process.exit(1);
-				}
-			}
-
-			// Validate we have necessary IDs
-			if (!orgId) {
-				ui.displayError(
-					'No organization selected. Run "tm context org" or use --org flag.'
-				);
-				process.exit(1);
-			}
-
-			if (!briefId) {
-				ui.displayError(
-					'No brief specified. Run "tm context brief", provide a brief ID/URL, or use --brief flag.'
-				);
-				process.exit(1);
-			}
-
-			// Confirm export if not auto-confirmed
-			if (!options?.yes) {
-				const confirmed = await this.confirmExport(orgId, briefId, context);
-				if (!confirmed) {
-					ui.displayWarning('Export cancelled');
-					this.lastResult = {
-						success: false,
-						action: 'cancelled',
-						message: 'User cancelled export'
-					};
-					process.exit(0);
-				}
-			}
-
-			// Perform export
-			spinner = ora('Exporting tasks...').start();
-
-			const exportResult = await this.taskMasterCore!.exportTasks({
-				orgId,
-				briefId,
-				tag: options?.tag,
-				status: options?.status,
-				excludeSubtasks: options?.excludeSubtasks || false
-			});
-
-			if (exportResult.success) {
-				spinner.succeed(
-					`Successfully exported ${exportResult.taskCount} task(s) to brief`
-				);
-
-				// Display summary
-				console.log(chalk.cyan('\n📤 Export Summary\n'));
-				console.log(chalk.white(`  Organization: ${orgId}`));
-				console.log(chalk.white(`  Brief: ${briefId}`));
-				console.log(chalk.white(`  Tasks exported: ${exportResult.taskCount}`));
-				if (options?.tag) {
-					console.log(chalk.gray(`  Tag: ${options.tag}`));
-				}
-				if (options?.status) {
-					console.log(chalk.gray(`  Status filter: ${options.status}`));
-				}
-
-				if (exportResult.message) {
-					console.log(chalk.gray(`\n  ${exportResult.message}`));
-				}
-			} else {
-				spinner.fail('Export failed');
-				if (exportResult.error) {
-					console.error(chalk.red(`\n✗ ${exportResult.error.message}`));
-				}
-			}
-
-			this.lastResult = {
-				success: exportResult.success,
-				action: 'export',
-				result: exportResult
-			};
-		} catch (error: any) {
-			if (spinner?.isSpinning) spinner.fail('Export failed');
-			this.handleError(error);
-			process.exit(1);
-		}
-	}
-
-	/**
-	 * Resolve brief input to get brief and org IDs
-	 */
-	private async resolveBriefInput(
-		briefOrUrl: string
-	): Promise<{ briefId: string; orgId: string } | null> {
-		try {
-			// Extract brief ID from input
-			const briefId = this.extractBriefId(briefOrUrl);
-			if (!briefId) {
-				return null;
-			}
-
-			// Fetch brief to get organization
-			const brief = await this.authManager.getBrief(briefId);
-			if (!brief) {
-				ui.displayError('Brief not found or you do not have access');
-				return null;
-			}
-
-			return {
-				briefId: brief.id,
-				orgId: brief.accountId
-			};
-		} catch (error) {
-			console.error(chalk.red(`Failed to resolve brief: ${error}`));
-			return null;
-		}
-	}
-
-	/**
-	 * Extract a brief ID from raw input (ID or URL)
-	 */
-	private extractBriefId(input: string): string | null {
-		const raw = input?.trim() ?? '';
-		if (!raw) return null;
-
-		const parseUrl = (s: string): URL | null => {
-			try {
-				return new URL(s);
-			} catch {}
-			try {
-				return new URL(`https://${s}`);
-			} catch {}
-			return null;
-		};
-
-		const fromParts = (path: string): string | null => {
-			const parts = path.split('/').filter(Boolean);
-			const briefsIdx = parts.lastIndexOf('briefs');
-			const candidate =
-				briefsIdx >= 0 && parts.length > briefsIdx + 1
-					? parts[briefsIdx + 1]
-					: parts[parts.length - 1];
-			return candidate?.trim() || null;
-		};
-
-		// Try URL parsing
-		const url = parseUrl(raw);
-		if (url) {
-			const qId = url.searchParams.get('id') || url.searchParams.get('briefId');
-			const candidate = (qId || fromParts(url.pathname)) ?? null;
-			if (candidate) {
-				if (this.isLikelyId(candidate) || candidate.length >= 8) {
-					return candidate;
-				}
-			}
-		}
-
-		// Check if it looks like a path
-		if (raw.includes('/')) {
-			const candidate = fromParts(raw);
-			if (candidate && (this.isLikelyId(candidate) || candidate.length >= 8)) {
-				return candidate;
-			}
-		}
-
-		// Return raw if it looks like an ID
-		return raw;
-	}
-
-	/**
-	 * Check if a string looks like a brief ID
-	 */
-	private isLikelyId(value: string): boolean {
-		const uuidRegex =
-			/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
-		const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
-		const slugRegex = /^[A-Za-z0-9_-]{16,}$/;
-		return (
-			uuidRegex.test(value) || ulidRegex.test(value) || slugRegex.test(value)
-		);
-	}
-
-	/**
-	 * Confirm export with the user
-	 */
-	private async confirmExport(
-		orgId: string,
-		briefId: string,
-		context: UserContext | null
-	): Promise<boolean> {
-		console.log(chalk.cyan('\n📤 Export Tasks\n'));
-
-		// Show org name if available
-		if (context?.orgName) {
-			console.log(chalk.white(`  Organization: ${context.orgName}`));
-			console.log(chalk.gray(`  ID: ${orgId}`));
-		} else {
-			console.log(chalk.white(`  Organization ID: ${orgId}`));
-		}
-
-		// Show brief info
-		if (context?.briefName) {
-			console.log(chalk.white(`\n  Brief: ${context.briefName}`));
-			console.log(chalk.gray(`  ID: ${briefId}`));
-		} else {
-			console.log(chalk.white(`\n  Brief ID: ${briefId}`));
-		}
-
-		const { confirmed } = await inquirer.prompt([
-			{
-				type: 'confirm',
-				name: 'confirmed',
-				message: 'Do you want to proceed with export?',
-				default: true
-			}
-		]);
-
-		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)
-	 */
-	public getLastResult(): ExportCommandResult | undefined {
-		return this.lastResult;
-	}
-
-	/**
-	 * Clean up resources
-	 */
-	async cleanup(): Promise<void> {
-		// No resources to clean up
-	}
-
-	/**
-	 * Register this command on an existing program
-	 */
-	static register(program: Command, name?: string): ExportCommand {
-		const exportCommand = new ExportCommand(name);
-		program.addCommand(exportCommand);
-		return exportCommand;
-	}
-}

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

@@ -246,7 +246,7 @@ export class ListTasksCommand extends Command {
 				task.subtasks.forEach((subtask) => {
 					const subIcon = STATUS_ICONS[subtask.status];
 					console.log(
-						`  ${chalk.gray(String(subtask.id))} ${subIcon} ${chalk.gray(subtask.title)}`
+						`  ${chalk.gray(`${task.id}.${subtask.id}`)} ${subIcon} ${chalk.gray(subtask.title)}`
 					);
 				});
 			}
@@ -281,14 +281,9 @@ export class ListTasksCommand extends Command {
 		const priorityBreakdown = getPriorityBreakdown(tasks);
 
 		// Find next task following the same logic as findNextTask
-		const nextTaskInfo = this.findNextTask(tasks);
+		const nextTask = this.findNextTask(tasks);
 
-		// Get the full task object with complexity data already included
+		// Display dashboard boxes
-		const nextTask = nextTaskInfo
-			? tasks.find((t) => String(t.id) === String(nextTaskInfo.id))
-			: undefined;
-
-		// Display dashboard boxes (nextTask already has complexity from storage enrichment)
 		displayDashboards(
 			taskStats,
 			subtaskStats,
@@ -297,7 +292,7 @@ export class ListTasksCommand extends Command {
 			nextTask
 		);
 
-		// Task table
+		// Task table - no title, just show the table directly
 		console.log(
 			ui.createTaskTable(tasks, {
 				showSubtasks: withSubtasks,
@@ -308,16 +303,14 @@ export class ListTasksCommand extends Command {
 
 		// Display recommended next task section immediately after table
 		if (nextTask) {
-			const description = getTaskDescription(nextTask);
+			// Find the full task object to get description
+			const fullTask = tasks.find((t) => String(t.id) === String(nextTask.id));
+			const description = fullTask ? getTaskDescription(fullTask) : undefined;
 
 			displayRecommendedNextTask({
-				id: nextTask.id,
+				...nextTask,
-				title: nextTask.title,
+				status: 'pending', // Next task is typically pending
-				priority: nextTask.priority,
+				description
-				status: nextTask.status,
-				dependencies: nextTask.dependencies,
-				description,
-				complexity: nextTask.complexity as number | undefined
 			});
 		} else {
 			displayRecommendedNextTask(undefined);
@@ -474,7 +467,18 @@ export class ListTasksCommand extends Command {
 	}
 
 	/**
-	 * Register this command on an existing program
+	 * Static method to register this command on an existing program
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const listCommand = new ListTasksCommand();
+		program.addCommand(listCommand);
+		return listCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
 	 */
 	static register(program: Command, name?: string): ListTasksCommand {
 		const listCommand = new ListTasksCommand(name);

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

@@ -258,6 +258,9 @@ export class SetStatusCommand extends Command {
 				)
 			);
 		}
+
+		// Show storage info
+		console.log(chalk.gray(`\nUsing ${result.storageType} storage`));
 	}
 
 	/**
@@ -287,7 +290,18 @@ export class SetStatusCommand extends Command {
 	}
 
 	/**
-	 * Register this command on an existing program
+	 * Static method to register this command on an existing program
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const setStatusCommand = new SetStatusCommand();
+		program.addCommand(setStatusCommand);
+		return setStatusCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
 	 */
 	static register(program: Command, name?: string): SetStatusCommand {
 		const setStatusCommand = new SetStatusCommand(name);

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

@@ -322,7 +322,18 @@ export class ShowCommand extends Command {
 	}
 
 	/**
-	 * Register this command on an existing program
+	 * Static method to register this command on an existing program
+	 * This is for gradual migration - allows commands.js to use this
+	 */
+	static registerOn(program: Command): Command {
+		const showCommand = new ShowCommand();
+		program.addCommand(showCommand);
+		return showCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 * Can also configure the command name if needed
 	 */
 	static register(program: Command, name?: string): ShowCommand {
 		const showCommand = new ShowCommand(name);

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

@@ -493,7 +493,16 @@ export class StartCommand extends Command {
 	}
 
 	/**
-	 * Register this command on an existing program
+	 * Static method to register this command on an existing program
+	 */
+	static registerOn(program: Command): Command {
+		const startCommand = new StartCommand();
+		program.addCommand(startCommand);
+		return startCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
 	 */
 	static register(program: Command, name?: string): StartCommand {
 		const startCommand = new StartCommand(name);

apps/cli/src/index.ts

@@ -10,15 +10,6 @@ export { AuthCommand } from './commands/auth.command.js';
 export { ContextCommand } from './commands/context.command.js';
 export { StartCommand } from './commands/start.command.js';
 export { SetStatusCommand } from './commands/set-status.command.js';
-export { ExportCommand } from './commands/export.command.js';
-
-// Command Registry
-export {
-	CommandRegistry,
-	registerAllCommands,
-	registerCommandsByCategory,
-	type CommandMetadata
-} from './command-registry.js';
 
 // UI utilities (for other commands to use)
 export * as ui from './utils/ui.js';

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

@@ -6,7 +6,6 @@
 import chalk from 'chalk';
 import boxen from 'boxen';
 import type { Task, TaskPriority } from '@tm/core/types';
-import { getComplexityWithColor } from '../../utils/ui.js';
 
 /**
  * Statistics for task collection
@@ -480,7 +479,7 @@ export function displayDependencyDashboard(
 				? chalk.cyan(nextTask.dependencies.join(', '))
 				: chalk.gray('None')
 		}\n` +
-		`Complexity: ${nextTask?.complexity !== undefined ? getComplexityWithColor(nextTask.complexity) : chalk.gray('N/A')}`;
+		`Complexity: ${nextTask?.complexity || chalk.gray('N/A')}`;
 
 	return content;
 }

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

@@ -6,7 +6,6 @@
 import chalk from 'chalk';
 import boxen from 'boxen';
 import type { Task } from '@tm/core/types';
-import { getComplexityWithColor } from '../../utils/ui.js';
 
 /**
  * Next task display options
@@ -18,7 +17,6 @@ export interface NextTaskDisplayOptions {
 	status?: string;
 	dependencies?: (string | number)[];
 	description?: string;
-	complexity?: number;
 }
 
 /**
@@ -84,11 +82,6 @@ export function displayRecommendedNextTask(
 			: chalk.cyan(task.dependencies.join(', '));
 	content.push(`Dependencies: ${depsDisplay}`);
 
-	// Complexity with color and label
-	if (typeof task.complexity === 'number') {
-		content.push(`Complexity: ${getComplexityWithColor(task.complexity)}`);
-	}
-
 	// Description if available
 	if (task.description) {
 		content.push('');

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

@@ -9,11 +9,7 @@ import Table from 'cli-table3';
 import { marked, MarkedExtension } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import type { Task } from '@tm/core/types';
-import {
+import { getStatusWithColor, getPriorityWithColor } from '../../utils/ui.js';
-	getStatusWithColor,
-	getPriorityWithColor,
-	getComplexityWithColor
-} from '../../utils/ui.js';
 
 // Configure marked to use terminal renderer with subtle colors
 marked.use(
@@ -112,9 +108,7 @@ export function displayTaskProperties(task: Task): void {
 		getStatusWithColor(task.status),
 		getPriorityWithColor(task.priority),
 		deps,
-		typeof task.complexity === 'number'
+		'N/A',
-			? getComplexityWithColor(task.complexity)
-			: chalk.gray('N/A'),
 		task.description || ''
 	].join('\n');
 
@@ -192,7 +186,8 @@ export function displaySubtasks(
 		status: any;
 		description?: string;
 		dependencies?: string[];
-	}>
+	}>,
+	parentId: string | number
 ): void {
 	const terminalWidth = process.stdout.columns * 0.95 || 100;
 	// Display subtasks header
@@ -227,7 +222,7 @@ export function displaySubtasks(
 	});
 
 	subtasks.forEach((subtask) => {
-		const subtaskId = String(subtask.id);
+		const subtaskId = `${parentId}.${subtask.id}`;
 
 		// Format dependencies
 		const deps =
@@ -328,7 +323,7 @@ export function displayTaskDetails(
 			console.log(chalk.gray(`  No subtasks with status '${statusFilter}'`));
 		} else if (filteredSubtasks.length > 0) {
 			console.log(); // Empty line for spacing
-			displaySubtasks(filteredSubtasks);
+			displaySubtasks(filteredSubtasks, task.id);
 		}
 	}
 

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

@@ -12,7 +12,6 @@ export interface UpdateInfo {
 	currentVersion: string;
 	latestVersion: string;
 	needsUpdate: boolean;
-	highlights?: string[];
 }
 
 /**
@@ -60,116 +59,6 @@ export function compareVersions(v1: string, v2: string): number {
 	return a.pre < b.pre ? -1 : 1; // basic prerelease tie-break
 }
 
-/**
- * Fetch CHANGELOG.md from GitHub and extract highlights for a specific version
- */
-async function fetchChangelogHighlights(version: string): Promise<string[]> {
-	return new Promise((resolve) => {
-		const options = {
-			hostname: 'raw.githubusercontent.com',
-			path: '/eyaltoledano/claude-task-master/main/CHANGELOG.md',
-			method: 'GET',
-			headers: {
-				'User-Agent': `task-master-ai/${version}`
-			}
-		};
-
-		const req = https.request(options, (res) => {
-			let data = '';
-
-			res.on('data', (chunk) => {
-				data += chunk;
-			});
-
-			res.on('end', () => {
-				try {
-					if (res.statusCode !== 200) {
-						resolve([]);
-						return;
-					}
-
-					const highlights = parseChangelogHighlights(data, version);
-					resolve(highlights);
-				} catch (error) {
-					resolve([]);
-				}
-			});
-		});
-
-		req.on('error', () => {
-			resolve([]);
-		});
-
-		req.setTimeout(3000, () => {
-			req.destroy();
-			resolve([]);
-		});
-
-		req.end();
-	});
-}
-
-/**
- * Parse changelog markdown to extract Minor Changes for a specific version
- * @internal - Exported for testing purposes only
- */
-export function parseChangelogHighlights(
-	changelog: string,
-	version: string
-): string[] {
-	try {
-		// Validate version format (basic semver pattern) to prevent ReDoS
-		if (!/^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(version)) {
-			return [];
-		}
-
-		// Find the version section
-		const versionRegex = new RegExp(
-			`## ${version.replace(/\./g, '\\.')}\\s*\\n`,
-			'i'
-		);
-		const versionMatch = changelog.match(versionRegex);
-
-		if (!versionMatch) {
-			return [];
-		}
-
-		// Extract content from this version to the next version heading
-		const startIdx = versionMatch.index! + versionMatch[0].length;
-		const nextVersionIdx = changelog.indexOf('\n## ', startIdx);
-		const versionContent =
-			nextVersionIdx > 0
-				? changelog.slice(startIdx, nextVersionIdx)
-				: changelog.slice(startIdx);
-
-		// Find Minor Changes section
-		const minorChangesMatch = versionContent.match(
-			/### Minor Changes\s*\n([\s\S]*?)(?=\n###|\n##|$)/i
-		);
-
-		if (!minorChangesMatch) {
-			return [];
-		}
-
-		const minorChangesContent = minorChangesMatch[1];
-		const highlights: string[] = [];
-
-		// Extract all bullet points (lines starting with -)
-		// Format: - [#PR](...) Thanks [@author]! - Description
-		const bulletRegex = /^-\s+\[#\d+\][^\n]*?!\s+-\s+(.+?)$/gm;
-		let match;
-
-		while ((match = bulletRegex.exec(minorChangesContent)) !== null) {
-			const desc = match[1].trim();
-			highlights.push(desc);
-		}
-
-		return highlights;
-	} catch (error) {
-		return [];
-	}
-}
-
 /**
  * Check for newer version of task-master-ai
  */
@@ -196,7 +85,7 @@ export async function checkForUpdate(
 				data += chunk;
 			});
 
-			res.on('end', async () => {
+			res.on('end', () => {
 				try {
 					if (res.statusCode !== 200)
 						throw new Error(`npm registry status ${res.statusCode}`);
@@ -206,17 +95,10 @@ export async function checkForUpdate(
 					const needsUpdate =
 						compareVersions(currentVersion, latestVersion) < 0;
 
-					// Fetch highlights if update is needed
-					let highlights: string[] | undefined;
-					if (needsUpdate) {
-						highlights = await fetchChangelogHighlights(latestVersion);
-					}
-
 					resolve({
 						currentVersion,
 						latestVersion,
-						needsUpdate,
+						needsUpdate
-						highlights
 					});
 				} catch (error) {
 					resolve({
@@ -254,29 +136,18 @@ export async function checkForUpdate(
  */
 export function displayUpgradeNotification(
 	currentVersion: string,
-	latestVersion: string,
+	latestVersion: string
-	highlights?: string[]
 ) {
-	let content = `${chalk.blue.bold('Update Available!')} ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}`;
+	const message = boxen(
-
+		`${chalk.blue.bold('Update Available!')} ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}\n\n` +
-	if (highlights && highlights.length > 0) {
+			`Auto-updating to the latest version with new features and bug fixes...`,
-		content += '\n\n' + chalk.bold("What's New:");
+		{
-		for (const highlight of highlights) {
+			padding: 1,
-			content += '\n' + chalk.cyan('• ') + highlight;
+			margin: { top: 1, bottom: 1 },
+			borderColor: 'yellow',
+			borderStyle: 'round'
 		}
-		content += '\n\n' + 'Auto-updating to the latest version...';
+	);
-	} else {
-		content +=
-			'\n\n' +
-			'Auto-updating to the latest version with new features and bug fixes...';
-	}
-
-	const message = boxen(content, {
-		padding: 1,
-		margin: { top: 1, bottom: 1 },
-		borderColor: 'yellow',
-		borderStyle: 'round'
-	});
 
 	console.log(message);
 }
@@ -287,18 +158,10 @@ export function displayUpgradeNotification(
 export async function performAutoUpdate(
 	latestVersion: string
 ): Promise<boolean> {
-	if (
+	if (process.env.TASKMASTER_SKIP_AUTO_UPDATE === '1' || process.env.CI) {
-		process.env.TASKMASTER_SKIP_AUTO_UPDATE === '1' ||
+		console.log(
-		process.env.CI ||
+			chalk.dim('Skipping auto-update (TASKMASTER_SKIP_AUTO_UPDATE/CI).')
-		process.env.NODE_ENV === 'test'
+		);
-	) {
-		const reason =
-			process.env.TASKMASTER_SKIP_AUTO_UPDATE === '1'
-				? 'TASKMASTER_SKIP_AUTO_UPDATE=1'
-				: process.env.CI
-					? 'CI environment'
-					: 'NODE_ENV=test';
-		console.log(chalk.dim(`Skipping auto-update (${reason})`));
 		return false;
 	}
 	const spinner = ora({

apps/cli/src/utils/ui.ts

@@ -84,23 +84,7 @@ export function getPriorityWithColor(priority: TaskPriority): string {
 }
 
 /**
- * Get complexity color and label based on score thresholds
+ * Get colored complexity display
- */
-function getComplexityLevel(score: number): {
-	color: (text: string) => string;
-	label: string;
-} {
-	if (score >= 7) {
-		return { color: chalk.hex('#CC0000'), label: 'High' };
-	} else if (score >= 4) {
-		return { color: chalk.hex('#FF8800'), label: 'Medium' };
-	} else {
-		return { color: chalk.green, label: 'Low' };
-	}
-}
-
-/**
- * Get colored complexity display with dot indicator (simple format)
  */
 export function getComplexityWithColor(complexity: number | string): string {
 	const score =
@@ -110,20 +94,13 @@ export function getComplexityWithColor(complexity: number | string): string {
 		return chalk.gray('N/A');
 	}
 
-	const { color } = getComplexityLevel(score);
+	if (score >= 8) {
-	return color(`● ${score}`);
+		return chalk.red.bold(`${score} (High)`);
-}
+	} else if (score >= 5) {
-
+		return chalk.yellow(`${score} (Medium)`);
-/**
+	} else {
- * Get colored complexity display with /10 format (for dashboards)
+		return chalk.green(`${score} (Low)`);
- */
-export function getComplexityWithScore(complexity: number | undefined): string {
-	if (typeof complexity !== 'number') {
-		return chalk.gray('N/A');
 	}
-
-	const { color, label } = getComplexityLevel(complexity);
-	return color(`${complexity}/10 (${label})`);
 }
 
 /**
@@ -286,12 +263,12 @@ export function createTaskTable(
 	// Adjust column widths to better match the original layout
 	const baseColWidths = showComplexity
 		? [
-				Math.floor(terminalWidth * 0.1),
+				Math.floor(terminalWidth * 0.06),
 				Math.floor(terminalWidth * 0.4),
 				Math.floor(terminalWidth * 0.15),
-				Math.floor(terminalWidth * 0.1),
+				Math.floor(terminalWidth * 0.12),
 				Math.floor(terminalWidth * 0.2),
-				Math.floor(terminalWidth * 0.1)
+				Math.floor(terminalWidth * 0.12)
 			] // ID, Title, Status, Priority, Dependencies, Complexity
 		: [
 				Math.floor(terminalWidth * 0.08),
@@ -346,12 +323,8 @@ export function createTaskTable(
 		}
 
 		if (showComplexity) {
-			// Show complexity score from report if available
+			// Show N/A if no complexity score
-			if (typeof task.complexity === 'number') {
+			row.push(chalk.gray('N/A'));
-				row.push(getComplexityWithColor(task.complexity));
-			} else {
-				row.push(chalk.gray('N/A'));
-			}
 		}
 
 		table.push(row);
@@ -377,11 +350,7 @@ export function createTaskTable(
 				}
 
 				if (showComplexity) {
-					const complexityDisplay =
+					subRow.push(chalk.gray('--'));
-						typeof subtask.complexity === 'number'
-							? getComplexityWithColor(subtask.complexity)
-							: '--';
-					subRow.push(chalk.gray(complexityDisplay));
 				}
 
 				table.push(subRow);

apps/docs/CHANGELOG.md

@@ -1,9 +1,5 @@
 # docs
 
-## 0.0.6
-
-## 0.0.5
-
 ## 0.0.4
 
 ## 0.0.3

apps/docs/capabilities/rpg-method.mdx

@@ -1,326 +0,0 @@
----
-title: RPG Method for PRD Creation
-sidebarTitle: "RPG Method"
----
-
-# Repository Planning Graph (RPG) Method
-
-The RPG (Repository Planning Graph) method is an advanced approach to creating Product Requirements Documents that generate highly-structured, dependency-aware task graphs. It's based on Microsoft Research's methodology for scalable codebase generation.
-
-## When to Use RPG
-
-Use the RPG template (`example_prd_rpg.txt`) for:
-
-- **Complex multi-module systems** with intricate dependencies
-- **Large-scale codebases** being built from scratch
-- **Projects requiring explicit architecture** and clear module boundaries
-- **Teams needing dependency visibility** for parallel development
-
-For simpler features or smaller projects, the standard `example_prd.txt` template may be more appropriate.
-
----
-
-## Core Principles
-
-### 1. Dual-Semantics
-
-Separate **functional** thinking (WHAT) from **structural** thinking (HOW):
-
-```
-Functional: "Data Validation capability with schema checking and rule enforcement"
-                    ↓
-Structural: "src/validation/ with schema-validator.js and rule-validator.js"
-```
-
-This separation prevents mixing concerns and creates clearer module boundaries.
-
-### 2. Explicit Dependencies
-
-Never assume dependencies - always state them explicitly:
-
-```
-Good:
-  Module: data-ingestion
-  Depends on: [schema-validator, config-manager]
-
-Bad:
-  Module: data-ingestion
-  (Assumes schema-validator exists somewhere)
-```
-
-Explicit dependencies enable:
-- Topological ordering of implementation
-- Parallel development of independent modules
-- Clear build/test order
-- Early detection of circular dependencies
-
-### 3. Topological Order
-
-Build foundation layers before higher layers:
-
-```
-Phase 0 (Foundation): error-handling, base-types, config
-                ↓
-Phase 1 (Data): validation, ingestion (depend on Phase 0)
-                ↓
-Phase 2 (Core): algorithms, pipelines (depend on Phase 1)
-                ↓
-Phase 3 (API): routes, handlers (depend on Phase 2)
-```
-
-Task Master automatically orders tasks based on this dependency chain.
-
-### 4. Progressive Refinement
-
-Start broad, refine iteratively:
-
-1. High-level capabilities → Main tasks
-2. Features per capability → Subtasks
-3. Implementation details → Expanded subtasks
-
----
-
-## Template Structure
-
-The RPG template guides you through 7 key sections:
-
-### 1. Overview
-- Problem statement
-- Target users
-- Success metrics
-
-### 2. Functional Decomposition (WHAT)
-- High-level capability domains
-- Features per capability
-- Inputs/outputs/behavior for each feature
-
-**Example:**
-```
-Capability: Data Management
-  Feature: Schema validation
-    Description: Validate JSON against defined schemas
-    Inputs: JSON object, schema definition
-    Outputs: Validation result + error details
-    Behavior: Iterate fields, check types, enforce constraints
-```
-
-### 3. Structural Decomposition (HOW)
-- Repository folder structure
-- Module-to-capability mapping
-- File organization
-- Public interfaces/exports
-
-**Example:**
-```
-Capability: Data Management
-  → Maps to: src/data/
-    ├── schema-validator.js    (Schema validation feature)
-    ├── rule-validator.js      (Rule validation feature)
-    └── index.js               (Exports)
-```
-
-### 4. Dependency Graph (CRITICAL)
-- Foundation layer (no dependencies)
-- Each subsequent layer's dependencies
-- Explicit "depends on" declarations
-
-**Example:**
-```
-Foundation Layer (Phase 0):
-  - error-handling: No dependencies
-  - base-types: No dependencies
-
-Data Layer (Phase 1):
-  - schema-validator: Depends on [base-types, error-handling]
-  - data-ingestion: Depends on [schema-validator]
-```
-
-### 5. Implementation Roadmap
-- Phases with entry/exit criteria
-- Tasks grouped by phase
-- Clear deliverables per phase
-
-### 6. Test Strategy
-- Test pyramid ratios
-- Coverage requirements
-- Critical test scenarios per module
-- Guidelines for test generation
-
-### 7. Architecture & Risks
-- Technical architecture
-- Data models
-- Technology decisions
-- Risk mitigation strategies
-
----
-
-## Using RPG with Task Master
-
-### Step 1: Create PRD with RPG Template
-
-Use a code-context-aware tool to fill out the template:
-
-```bash
-# In Claude Code, Cursor, or similar
-"Create a PRD using @.taskmaster/templates/example_prd_rpg.txt for [your project]"
-```
-
-**Why code context matters:** The AI needs to understand your existing codebase to make informed decisions about:
-- Module boundaries
-- Dependency relationships
-- Integration points
-- Naming conventions
-
-**Recommended tools:**
-- Claude Code (claude-code CLI)
-- Cursor/Windsurf
-- Gemini CLI (large contexts)
-- Codex/Grok CLI
-
-### Step 2: Parse PRD into Tasks
-
-```bash
-task-master parse-prd .taskmaster/docs/your-prd.txt --research
-```
-
-Task Master will:
-1. Extract capabilities → Main tasks
-2. Extract features → Subtasks
-3. Parse dependencies → Task dependencies
-4. Order by phases → Task priorities
-
-**Result:** A dependency-aware task graph ready for topological execution.
-
-### Step 3: Analyze Complexity
-
-```bash
-task-master analyze-complexity --research
-```
-
-Review the complexity report to identify tasks that need expansion.
-
-### Step 4: Expand Tasks
-
-```bash
-task-master expand --all --research
-```
-
-Break down complex tasks into manageable subtasks while preserving dependency chains.
-
----
-
-## RPG Benefits
-
-### For Solo Developers
-- Clear roadmap for implementing complex features
-- Prevents architectural mistakes early
-- Explicit dependency tracking avoids integration issues
-- Enables resuming work after interruptions
-
-### For Teams
-- Parallel development of independent modules
-- Clear contracts between modules (explicit dependencies)
-- Reduced merge conflicts (proper module boundaries)
-- Onboarding aid (architectural overview in PRD)
-
-### For AI Agents
-- Structured context for code generation
-- Clear scope boundaries per task
-- Dependency awareness prevents incomplete implementations
-- Test strategy guidance for TDD workflows
-
----
-
-## RPG vs Standard Template
-
-| Aspect | Standard Template | RPG Template |
-|--------|------------------|--------------|
-| **Best for** | Simple features | Complex systems |
-| **Dependency handling** | Implicit | Explicit graph |
-| **Structure guidance** | Minimal | Step-by-step |
-| **Examples** | Few | Inline good/bad examples |
-| **Module boundaries** | Vague | Precise mapping |
-| **Task ordering** | Manual | Automatic (topological) |
-| **Learning curve** | Low | Medium |
-| **Resulting task quality** | Good | Excellent |
-
----
-
-## Tips for Best Results
-
-### 1. Spend Time on Dependencies
-The dependency graph section is the most valuable. List all dependencies explicitly, even if they seem obvious.
-
-### 2. Keep Features Atomic
-Each feature should be independently testable. If a feature description is vague ("handle data"), break it into specific features.
-
-### 3. Progressive Refinement
-Don't try to get everything perfect on the first pass:
-1. Fill out high-level sections
-2. Review and refine
-3. Add detail where needed
-4. Let `task-master expand` break down complex tasks further
-
-### 4. Use Research Mode
-```bash
-task-master parse-prd --research
-```
-The `--research` flag leverages AI to enhance task generation with domain knowledge.
-
-### 5. Validate Early
-```bash
-task-master validate-dependencies
-```
-Check for circular dependencies or orphaned modules before starting implementation.
-
----
-
-## Common Pitfalls
-
-### ❌ Mixing Functional and Structural
-```
-Bad: "Capability: validation.js"
-Good: "Capability: Data Validation" → maps to "src/validation/"
-```
-
-### ❌ Vague Module Boundaries
-```
-Bad: "Module: utils"
-Good: "Module: string-utilities" with clear exports
-```
-
-### ❌ Implicit Dependencies
-```
-Bad: "Module: API handlers (needs validation)"
-Good: "Module: API handlers, Depends on: [validation, error-handling]"
-```
-
-### ❌ Skipping Test Strategy
-Without test strategy, the AI won't know what to test during implementation.
-
----
-
-## Example Workflow
-
-1. **Discuss idea with AI**: Explain your project concept
-2. **Reference RPG template**: Show AI the `example_prd_rpg.txt`
-3. **Co-create PRD**: Work through each section with AI guidance
-4. **Save to docs**: Place in `.taskmaster/docs/your-project.txt`
-5. **Parse PRD**: `task-master parse-prd .taskmaster/docs/your-project.txt --research`
-6. **Analyze**: `task-master analyze-complexity --research`
-7. **Expand**: `task-master expand --all --research`
-8. **Start work**: `task-master next`
-
----
-
-## Further Reading
-
-- [PRD Creation and Parsing Guide](/getting-started/quick-start/prd-quick)
-- [Task Structure Documentation](/capabilities/task-structure)
-- [Microsoft Research RPG Paper](https://arxiv.org/abs/2410.21376) (Original methodology)
-
----
-
-<Tip>
-The RPG template includes inline `<instruction>` and `<example>` blocks that teach the method as you use it. Read these sections carefully - they provide valuable guidance at each decision point.
-</Tip>

apps/docs/docs.json

@@ -32,7 +32,6 @@
 									"getting-started/quick-start/execute-quick"
 								]
 							},
-							"getting-started/api-keys",
 							"getting-started/faq",
 							"getting-started/contribute"
 						]

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

@@ -1,267 +0,0 @@
-# API Keys Configuration
-
-Task Master supports multiple AI providers through environment variables. This page lists all available API keys and their configuration requirements.
-
-## Required API Keys
-
-> **Note**: At least one required API key must be configured for Task Master to function.
->
-> "Required: Yes" below means "required to use that specific provider," not "required globally." You only need at least one provider configured.
-
-### ANTHROPIC_API_KEY (Recommended)
-- **Provider**: Anthropic Claude models
-- **Format**: `sk-ant-api03-...`
-- **Required**: ✅ **Yes**
-- **Models**: Claude 3.5 Sonnet, Claude 3 Haiku, Claude 3 Opus
-- **Get Key**: [Anthropic Console](https://console.anthropic.com/)
-
-```bash
-ANTHROPIC_API_KEY="sk-ant-api03-your-key-here"
-```
-
-### PERPLEXITY_API_KEY (Highly Recommended for Research)
-- **Provider**: Perplexity AI (Research features)
-- **Format**: `pplx-...`
-- **Required**: ✅ **Yes**
-- **Purpose**: Enables research-backed task expansions and updates
-- **Models**: Perplexity Sonar models
-- **Get Key**: [Perplexity API](https://www.perplexity.ai/settings/api)
-
-```bash
-PERPLEXITY_API_KEY="pplx-your-key-here"
-```
-
-### OPENAI_API_KEY
-- **Provider**: OpenAI GPT models
-- **Format**: `sk-proj-...` or `sk-...`
-- **Required**: ✅ **Yes**
-- **Models**: GPT-4, GPT-4 Turbo, GPT-3.5 Turbo, O1 models
-- **Get Key**: [OpenAI Platform](https://platform.openai.com/api-keys)
-
-```bash
-OPENAI_API_KEY="sk-proj-your-key-here"
-```
-
-### GOOGLE_API_KEY
-- **Provider**: Google Gemini models
-- **Format**: Various formats
-- **Required**: ✅ **Yes**
-- **Models**: Gemini Pro, Gemini Flash, Gemini Ultra
-- **Get Key**: [Google AI Studio](https://aistudio.google.com/app/apikey)
-- **Alternative**: Use `GOOGLE_APPLICATION_CREDENTIALS` for service account (Google Vertex)
-
-```bash
-GOOGLE_API_KEY="your-google-api-key-here"
-```
-
-### GROQ_API_KEY
-- **Provider**: Groq (High-performance inference)
-- **Required**: ✅ **Yes**
-- **Models**: Llama models, Mixtral models (via Groq)
-- **Get Key**: [Groq Console](https://console.groq.com/keys)
-
-```bash
-GROQ_API_KEY="your-groq-key-here"
-```
-
-### OPENROUTER_API_KEY
-- **Provider**: OpenRouter (Multiple model access)
-- **Required**: ✅ **Yes**
-- **Models**: Access to various models through single API
-- **Get Key**: [OpenRouter](https://openrouter.ai/keys)
-
-```bash
-OPENROUTER_API_KEY="your-openrouter-key-here"
-```
-
-### AZURE_OPENAI_API_KEY
-- **Provider**: Azure OpenAI Service
-- **Required**: ✅ **Yes**
-- **Requirements**: Also requires `AZURE_OPENAI_ENDPOINT` configuration
-- **Models**: GPT models via Azure
-- **Get Key**: [Azure Portal](https://portal.azure.com/)
-
-```bash
-AZURE_OPENAI_API_KEY="your-azure-key-here"
-```
-
-### XAI_API_KEY
-- **Provider**: xAI (Grok) models
-- **Required**: ✅ **Yes**
-- **Models**: Grok models
-- **Get Key**: [xAI Console](https://console.x.ai/)
-
-```bash
-XAI_API_KEY="your-xai-key-here"
-```
-
-## Optional API Keys
-
-> **Note**: These API keys are optional - providers will work without them or use alternative authentication methods.
-
-### AWS_ACCESS_KEY_ID (Bedrock)
-- **Provider**: AWS Bedrock
-- **Required**: ❌ **No** (uses AWS credential chain)
-- **Models**: Claude models via AWS Bedrock
-- **Authentication**: Uses AWS credential chain (profiles, IAM roles, etc.)
-- **Get Key**: [AWS Console](https://console.aws.amazon.com/iam/)
-
-```bash
-# Optional - AWS credential chain is preferred
-AWS_ACCESS_KEY_ID="your-aws-access-key"
-AWS_SECRET_ACCESS_KEY="your-aws-secret-key"
-```
-
-### CLAUDE_CODE_API_KEY
-- **Provider**: Claude Code CLI
-- **Required**: ❌ **No** (uses OAuth tokens)
-- **Purpose**: Integration with local Claude Code CLI
-- **Authentication**: Uses OAuth tokens, no API key needed
-
-```bash
-# Not typically needed
-CLAUDE_CODE_API_KEY="not-usually-required"
-```
-
-### GEMINI_API_KEY
-- **Provider**: Gemini CLI
-- **Required**: ❌ **No** (uses OAuth authentication)
-- **Purpose**: Integration with Gemini CLI
-- **Authentication**: Primarily uses OAuth via CLI, API key is optional
-
-```bash
-# Optional - OAuth via CLI is preferred
-GEMINI_API_KEY="your-gemini-key-here"
-```
-
-### GROK_CLI_API_KEY
-- **Provider**: Grok CLI
-- **Required**: ❌ **No** (can use CLI config)
-- **Purpose**: Integration with Grok CLI
-- **Authentication**: Can use Grok CLI's own config file
-
-```bash
-# Optional - CLI config is preferred
-GROK_CLI_API_KEY="your-grok-cli-key"
-```
-
-### OLLAMA_API_KEY
-- **Provider**: Ollama (Local/Remote)
-- **Required**: ❌ **No** (local installation doesn't need key)
-- **Purpose**: For remote Ollama servers that require authentication
-- **Requirements**: Only needed for remote servers with authentication
-- **Note**: Not needed for local Ollama installations
-
-```bash
-# Only needed for remote Ollama servers
-OLLAMA_API_KEY="your-ollama-api-key-here"
-```
-
-### GITHUB_API_KEY
-- **Provider**: GitHub (Import/Export features)
-- **Format**: `ghp_...` or `github_pat_...`
-- **Required**: ❌ **No** (for GitHub features only)
-- **Purpose**: GitHub import/export features
-- **Get Key**: [GitHub Settings](https://github.com/settings/tokens)
-
-```bash
-GITHUB_API_KEY="ghp-your-github-key-here"
-```
-
-## Configuration Methods
-
-### Method 1: Environment File (.env)
-Create a `.env` file in your project root:
-
-```bash
-# Copy from .env.example
-cp .env.example .env
-
-# Edit with your keys
-vim .env
-```
-
-### Method 2: System Environment Variables
-```bash
-export ANTHROPIC_API_KEY="your-key-here"
-export PERPLEXITY_API_KEY="your-key-here"
-# ... other keys
-```
-
-### Method 3: MCP Server Configuration
-For Claude Code integration, configure keys in `.mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "task-master-ai": {
-      "command": "npx",
-      "args": ["-y", "task-master-ai"],
-      "env": {
-        "ANTHROPIC_API_KEY": "your-key-here",
-        "PERPLEXITY_API_KEY": "your-key-here",
-        "OPENAI_API_KEY": "your-key-here"
-      }
-    }
-  }
-}
-```
-
-## Key Requirements
-
-### Minimum Requirements
-- **At least one** AI provider key is required
-- **ANTHROPIC_API_KEY** is recommended as the primary provider
-- **PERPLEXITY_API_KEY** is highly recommended for research features
-
-### Provider-Specific Requirements
-- **Azure OpenAI**: Requires both `AZURE_OPENAI_API_KEY` and `AZURE_OPENAI_ENDPOINT` configuration
-- **Google Vertex**: Requires `VERTEX_PROJECT_ID` and `VERTEX_LOCATION` environment variables
-- **AWS Bedrock**: Uses AWS credential chain (profiles, IAM roles, etc.) instead of API keys
-- **Ollama**: Only needs API key for remote servers with authentication
-- **CLI Providers**: Gemini CLI, Grok CLI, and Claude Code use OAuth/CLI config instead of API keys
-
-## Model Configuration
-
-After setting up API keys, configure which models to use:
-
-```bash
-# Interactive model setup
-task-master models --setup
-
-# Set specific models
-task-master models --set-main claude-3-5-sonnet-20241022
-task-master models --set-research perplexity-llama-3.1-sonar-large-128k-online
-task-master models --set-fallback gpt-4o-mini
-```
-
-## Security Best Practices
-
-1. **Never commit API keys** to version control
-2. **Use .env files** and add them to `.gitignore`
-3. **Rotate keys regularly** especially if compromised
-4. **Use minimal permissions** for service accounts
-5. **Monitor usage** to detect unauthorized access
-
-## Troubleshooting
-
-### Key Validation
-```bash
-# Check if keys are properly configured
-task-master models
-
-# Test specific provider
-task-master add-task --prompt="test task" --model=claude-3-5-sonnet-20241022
-```
-
-### Common Issues
-- **Invalid key format**: Check the expected format for each provider
-- **Insufficient permissions**: Ensure keys have necessary API access
-- **Rate limits**: Some providers have usage limits
-- **Regional restrictions**: Some models may not be available in all regions
-
-### Getting Help
-If you encounter issues with API key configuration:
-- Check the [FAQ](/getting-started/faq) for common solutions
-- Join our [Discord community](https://discord.gg/fWJkU7rf) for support
-- Report issues on [GitHub](https://github.com/eyaltoledano/claude-task-master/issues)

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

@@ -32,11 +32,7 @@ The more context you give the model, the better the breakdown and results.
 
 ## Writing a PRD for Task Master
 
-<Note>
+<Note>An example PRD can be found in .taskmaster/templates/example_prd.txt</Note>
-Two example PRD templates are available in `.taskmaster/templates/`:
-- `example_prd.txt` - Simple template for straightforward projects
-- `example_prd_rpg.txt` - Advanced RPG (Repository Planning Graph) template for complex projects with dependencies
-</Note>
 
 
 You can co-write your PRD with an LLM model using the following workflow:
@@ -47,29 +43,6 @@ You can co-write your PRD with an LLM model using the following workflow:
 
 This approach works great in Cursor, or anywhere you use a chat-based LLM.
 
-### Choosing Between Templates
-
-**Use `example_prd.txt` when:**
-- Building straightforward features
-- Working on smaller projects
-- Dependencies are simple and obvious
-
-**Use `example_prd_rpg.txt` when:**
-- Building complex systems with multiple modules
-- Need explicit dependency management
-- Want structured guidance on architecture decisions
-- Planning a large codebase from scratch
-
-The RPG template teaches you to think about:
-1. **Functional decomposition** (WHAT the system does)
-2. **Structural decomposition** (HOW it's organized in code)
-3. **Explicit dependencies** (WHAT depends on WHAT)
-4. **Topological ordering** (build foundation first, then layers)
-
-<Tip>
-For complex projects, using the RPG template with a code-context-aware ai agent produces the best results because the AI can understand your existing codebase structure. [Learn more about the RPG method →](/capabilities/rpg-method)
-</Tip>
-
 ---
 
 ## Where to Save Your PRD

apps/docs/package.json

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

apps/extension/CHANGELOG.md

@@ -1,35 +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
-
-- Updated dependencies [[`b43b7ce`](https://github.com/eyaltoledano/claude-task-master/commit/b43b7ce201625eee956fb2f8cd332f238bb78c21), [`aaacc3d`](https://github.com/eyaltoledano/claude-task-master/commit/aaacc3dae36247b4de72b2d2697f49e5df6d01e3), [`0079b7d`](https://github.com/eyaltoledano/claude-task-master/commit/0079b7defdad550811f704c470fdd01955d91d4d), [`0b2c696`](https://github.com/eyaltoledano/claude-task-master/commit/0b2c6967c4605c33a100cff16f6ce8ff09ad06f0), [`4f984f8`](https://github.com/eyaltoledano/claude-task-master/commit/4f984f8a6965da9f9c7edd60ddfd6560ac022917), [`7b5a7c4`](https://github.com/eyaltoledano/claude-task-master/commit/7b5a7c4495a68b782f7407fc5d0e0d3ae81f42f5), [`caee040`](https://github.com/eyaltoledano/claude-task-master/commit/caee040907f856d31a660171c9e6d966f23c632e), [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042), [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042), [`738ec51`](https://github.com/eyaltoledano/claude-task-master/commit/738ec51c049a295a12839b2dfddaf05e23b8fede), [`d67b81d`](https://github.com/eyaltoledano/claude-task-master/commit/d67b81d25ddd927fabb6f5deb368e8993519c541), [`b5fe723`](https://github.com/eyaltoledano/claude-task-master/commit/b5fe723f8ead928e9f2dbde13b833ee70ac3382d), [`2b69936`](https://github.com/eyaltoledano/claude-task-master/commit/2b69936ee7b34346d6de5175af20e077359e2e2a), [`986ac11`](https://github.com/eyaltoledano/claude-task-master/commit/986ac117aee00bcd3e6830a0f76e1ad6d10e0bca), [`20004a3`](https://github.com/eyaltoledano/claude-task-master/commit/20004a39ea848f747e1ff48981bfe176554e4055)]:
-  - task-master-ai@0.28.0
-
-## 0.25.5-rc.0
-
-### Patch Changes
-
-- Updated dependencies [[`aaacc3d`](https://github.com/eyaltoledano/claude-task-master/commit/aaacc3dae36247b4de72b2d2697f49e5df6d01e3), [`0079b7d`](https://github.com/eyaltoledano/claude-task-master/commit/0079b7defdad550811f704c470fdd01955d91d4d), [`0b2c696`](https://github.com/eyaltoledano/claude-task-master/commit/0b2c6967c4605c33a100cff16f6ce8ff09ad06f0), [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042), [`18aa416`](https://github.com/eyaltoledano/claude-task-master/commit/18aa416035f44345bde1c7321490345733a5d042), [`738ec51`](https://github.com/eyaltoledano/claude-task-master/commit/738ec51c049a295a12839b2dfddaf05e23b8fede), [`d67b81d`](https://github.com/eyaltoledano/claude-task-master/commit/d67b81d25ddd927fabb6f5deb368e8993519c541), [`b5fe723`](https://github.com/eyaltoledano/claude-task-master/commit/b5fe723f8ead928e9f2dbde13b833ee70ac3382d), [`2b69936`](https://github.com/eyaltoledano/claude-task-master/commit/2b69936ee7b34346d6de5175af20e077359e2e2a), [`986ac11`](https://github.com/eyaltoledano/claude-task-master/commit/986ac117aee00bcd3e6830a0f76e1ad6d10e0bca), [`20004a3`](https://github.com/eyaltoledano/claude-task-master/commit/20004a39ea848f747e1ff48981bfe176554e4055)]:
-  - task-master-ai@0.28.0-rc.0
-
-## 0.25.4
-
-### Patch Changes
-
-- Updated dependencies [[`af53525`](https://github.com/eyaltoledano/claude-task-master/commit/af53525cbc660a595b67d4bb90d906911c71f45d)]:
-  - task-master-ai@0.27.3
-
 ## 0.25.3
 
 ### Patch Changes

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.3",
 	"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": "0.27.2"
+	},
 	"devDependencies": {
 		"@dnd-kit/core": "^6.3.1",
 		"@dnd-kit/modifiers": "^9.0.0",
@@ -273,9 +276,7 @@
 		"react-dom": "^19.0.0",
 		"tailwind-merge": "^3.3.1",
 		"tailwindcss": "4.1.11",
-		"typescript": "^5.9.2",
+		"typescript": "^5.7.3"
-		"@tm/core": "*",
-		"task-master-ai": "*"
 	},
 	"overrides": {
 		"glob@<8": "^10.4.5",

apps/extension/package.publish.json

@@ -2,7 +2,7 @@
 	"name": "task-master-hamster",
 	"displayName": "Taskmaster AI",
 	"description": "A visual Kanban board interface for Taskmaster projects in VS Code",
-	"version": "0.25.3",
+	"version": "0.23.1",
 	"publisher": "Hamster",
 	"icon": "assets/icon.png",
 	"engines": {

apps/extension/tsconfig.json

@@ -5,6 +5,7 @@
 		"outDir": "out",
 		"lib": ["ES2022", "DOM"],
 		"sourceMap": true,
+		"rootDir": "src",
 		"strict": true /* enable all strict type-checking options */,
 		"moduleResolution": "Node",
 		"esModuleInterop": true,
@@ -20,10 +21,8 @@
 			"@/*": ["./src/*"],
 			"@/components/*": ["./src/components/*"],
 			"@/lib/*": ["./src/lib/*"],
-			"@tm/core": ["../../packages/tm-core/src/index.ts"],
+			"@tm/core": ["../core/src"]
-			"@tm/core/*": ["../../packages/tm-core/src/*"]
 		}
 	},
-	"include": ["src/**/*"],
 	"exclude": ["node_modules", ".vscode-test", "out", "dist"]
 }

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