chore: exit rc mode

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

.changeset/config.json

@@ -2,13 +2,16 @@
   "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
   "changelog": [
     "@changesets/changelog-github",
-    { "repo": "eyaltoledano/claude-task-master" }
+    {
+      "repo": "eyaltoledano/claude-task-master"
+    }
   ],
   "commit": false,
   "fixed": [],
-  "linked": [],
   "access": "public",
   "baseBranch": "main",
-  "updateInternalDependencies": "patch",
-  "ignore": []
+  "ignore": [
+    "docs",
+    "@tm/claude-code-plugin"
+  ]
 }

.changeset/dirty-hairs-know.md

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

.changeset/fix-gemini-cli-dependency.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Fix compatibility with @google/gemini-cli-core v0.1.12+ by updating ai-sdk-provider-gemini-cli to v0.1.1.

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

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

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

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

.changeset/fresh-bugs-squashed.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Fix 'expand --all' and 'show' commands to correctly handle tag contexts for complexity reports and task display.

.changeset/happy-sites-stay.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Clean up remaining automatic task file generation calls

.changeset/kind-lines-melt.md

@@ -0,0 +1,21 @@
+---
+"task-master-ai": patch
+---
+
+Fix MCP server compatibility with Draft-07 clients (Augment IDE, gemini-cli, gemini code assist)
+
+- Resolves #1284
+
+**Problem:**
+
+- MCP tools were using Zod v4, which outputs JSON Schema Draft 2020-12
+- MCP clients only support Draft-07
+- Tools were not discoverable in gemini-cli and other clients
+
+**Solution:**
+
+- Updated all MCP tools to import from `zod/v3` instead of `zod`
+- Zod v3 schemas convert to Draft-07 via FastMCP's zod-to-json-schema
+- Fixed logger to use stderr instead of stdout (MCP protocol requirement)
+
+This is a temporary workaround until FastMCP adds JSON Schema version configuration.

.changeset/light-owls-stay.md

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

.changeset/metal-rocks-help.md

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

.changeset/open-tips-notice.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": minor
+---
+
+Add 4.5 haiku and sonnet to supported models for claude-code and anthropic ai providers

.changeset/orange-pots-add.md

@@ -1,24 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add comprehensive Kiro IDE integration with autonomous task management hooks
-
-- **Kiro Profile**: Added full support for Kiro IDE with automatic installation of 7 Taskmaster agent hooks
-- **Hook-Driven Workflow**: Introduced natural language automation hooks that eliminate manual task status updates
-- **Automatic Hook Installation**: Hooks are now automatically copied to `.kiro/hooks/` when running `task-master rules add kiro`
-- **Language-Agnostic Support**: All hooks support multiple programming languages (JS, Python, Go, Rust, Java, etc.)
-- **Frontmatter Transformation**: Kiro rules use simplified `inclusion: always` format instead of Cursor's complex frontmatter
-- **Special Rule**: Added `taskmaster_hooks_workflow.md` that guides AI assistants to prefer hook-driven completion
-
-Key hooks included:
-
-- Task Dependency Auto-Progression: Automatically starts tasks when dependencies complete
-- Code Change Task Tracker: Updates task progress as you save files
-- Test Success Task Completer: Marks tasks done when tests pass
-- Daily Standup Assistant: Provides personalized task status summaries
-- PR Readiness Checker: Validates task completion before creating pull requests
-- Complexity Analyzer: Auto-expands complex tasks into manageable subtasks
-- Git Commit Task Linker: Links commits to tasks for better traceability
-
-This creates a truly autonomous development workflow where task management happens naturally as you code!

.changeset/pre.json

@@ -0,0 +1,25 @@
+{
+  "mode": "exit",
+  "tag": "rc",
+  "initialVersions": {
+    "task-master-ai": "0.29.0",
+    "@tm/cli": "",
+    "docs": "0.0.6",
+    "extension": "0.25.6",
+    "@tm/mcp": "0.28.0-rc.2",
+    "@tm/ai-sdk-provider-grok-cli": "",
+    "@tm/build-config": "",
+    "@tm/claude-code-plugin": "0.0.2",
+    "@tm/core": ""
+  },
+  "changesets": [
+    "dirty-hairs-know",
+    "fix-parent-directory-traversal",
+    "fix-warning-box-alignment",
+    "kind-lines-melt",
+    "light-owls-stay",
+    "metal-rocks-help",
+    "open-tips-notice",
+    "some-dodos-wonder"
+  ]
+}

.changeset/some-dodos-wonder.md

@@ -0,0 +1,36 @@
+---
+"task-master-ai": minor
+---
+
+Add autonomous TDD workflow automation system with new `tm autopilot` commands and MCP tools for AI-driven test-driven development.
+
+**New CLI Commands:**
+
+- `tm autopilot start <taskId>` - Initialize TDD workflow
+- `tm autopilot next` - Get next action in workflow
+- `tm autopilot status` - Check workflow progress
+- `tm autopilot complete` - Advance phase with test results
+- `tm autopilot commit` - Save progress with metadata
+- `tm autopilot resume` - Continue from checkpoint
+- `tm autopilot abort` - Cancel workflow
+
+**New MCP Tools:**
+Seven new autopilot tools for programmatic control: `autopilot_start`, `autopilot_next`, `autopilot_status`, `autopilot_complete_phase`, `autopilot_commit`, `autopilot_resume`, `autopilot_abort`
+
+**Features:**
+
+- Complete RED → GREEN → COMMIT cycle enforcement
+- Intelligent commit message generation with metadata
+- Activity logging and state persistence
+- Configurable workflow settings via `.taskmaster/config.json`
+- Comprehensive AI agent integration documentation
+
+**Documentation:**
+
+- AI Agent Integration Guide (2,800+ lines)
+- TDD Quick Start Guide
+- Example prompts and integration patterns
+
+> **Learn more:** [TDD Workflow Quickstart Guide](https://dev.task-master.dev/tdd-workflow/quickstart)
+
+This release enables AI agents to autonomously execute test-driven development workflows with full state management and recovery capabilities.

.changeset/swift-otters-argue.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Fix VSCode profile generation to use correct rule file names (using `.instructions.md` extension instead of `.md`) and front-matter properties (removing the unsupported `alwaysApply` property from instructions files' front-matter).

.claude-plugin/marketplace.json

@@ -0,0 +1,32 @@
+{
+	"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/commands/dedupe.md

@@ -0,0 +1,38 @@
+---
+allowed-tools: Bash(gh issue view:*), Bash(gh search:*), Bash(gh issue list:*), Bash(gh api:*), Bash(gh issue comment:*)
+description: Find duplicate GitHub issues
+---
+
+Find up to 3 likely duplicate issues for a given GitHub issue.
+
+To do this, follow these steps precisely:
+
+1. Use an agent to check if the Github issue (a) is closed, (b) does not need to be deduped (eg. because it is broad product feedback without a specific solution, or positive feedback), or (c) already has a duplicates comment that you made earlier. If so, do not proceed.
+2. Use an agent to view a Github issue, and ask the agent to return a summary of the issue
+3. Then, launch 5 parallel agents to search Github for duplicates of this issue, using diverse keywords and search approaches, using the summary from #1
+4. Next, feed the results from #1 and #2 into another agent, so that it can filter out false positives, that are likely not actually duplicates of the original issue. If there are no duplicates remaining, do not proceed.
+5. Finally, comment back on the issue with a list of up to three duplicate issues (or zero, if there are no likely duplicates)
+
+Notes (be sure to tell this to your agents, too):
+
+- Use `gh` to interact with Github, rather than web fetch
+- Do not use other tools, beyond `gh` (eg. don't use other MCP servers, file edit, etc.)
+- Make a todo list first
+- For your comment, follow the following format precisely (assuming for this example that you found 3 suspected duplicates):
+
+---
+
+Found 3 possible duplicate issues:
+
+1. <link to issue>
+2. <link to issue>
+3. <link to issue>
+
+This issue will be automatically closed as a duplicate in 3 days.
+
+- If your issue is a duplicate, please close it and 👍 the existing issue instead
+- To prevent auto-closure, add a comment or 👎 this comment
+
+🤖 Generated with \[Task Master Bot\]
+
+---

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

@@ -1,76 +0,0 @@
-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

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

@@ -1,81 +0,0 @@
-Automatically fix dependency issues found during validation.
-
-## Automatic Dependency Repair
-
-Intelligently fixes common dependency problems while preserving project logic.
-
-## Execution
-
-```bash
-task-master fix-dependencies
-```
-
-## What Gets Fixed
-
-### 1. **Auto-Fixable Issues**
-- Remove references to deleted tasks
-- Break simple circular dependencies
-- Remove self-dependencies
-- Clean up duplicate dependencies
-
-### 2. **Smart Resolutions**
-- Reorder dependencies to maintain logic
-- Suggest task merging for over-dependent tasks
-- Flatten unnecessary dependency chains
-- Remove redundant transitive dependencies
-
-### 3. **Manual Review Required**
-- Complex circular dependencies
-- Critical path modifications
-- Business logic dependencies
-- High-impact changes
-
-## Fix Process
-
-1. **Analysis Phase**
-   - Run validation check
-   - Categorize issues by type
-   - Determine fix strategy
-
-2. **Execution Phase**
-   - Apply automatic fixes
-   - Log all changes made
-   - Preserve task relationships
-
-3. **Verification Phase**
-   - Re-validate after fixes
-   - Show before/after comparison
-   - Highlight manual fixes needed
-
-## Smart Features
-
-- Preserves intended task flow
-- Minimal disruption approach
-- Creates fix history/log
-- Suggests manual interventions
-
-## Output Example
-
-```
-Dependency Auto-Fix Report
-━━━━━━━━━━━━━━━━━━━━━━━━
-Fixed Automatically:
-✅ Removed 2 references to deleted tasks
-✅ Resolved 1 self-dependency
-✅ Cleaned 3 redundant dependencies
-
-Manual Review Needed:
-⚠️ Complex circular dependency: #12 → #15 → #18 → #12
-  Suggestion: Make #15 not depend on #12
-⚠️ Task #45 has 8 dependencies
-  Suggestion: Break into subtasks
-
-Run '/project:tm/validate-dependencies' to verify fixes
-```
-
-## Safety
-
-- Preview mode available
-- Rollback capability
-- Change logging
-- No data loss

.claude/commands/tm/help.md

@@ -1,81 +0,0 @@
-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

@@ -1,46 +0,0 @@
-Quick initialization with auto-confirmation.
-
-Arguments: $ARGUMENTS
-
-Initialize a Task Master project without prompts, accepting all defaults.
-
-## Quick Setup
-
-```bash
-task-master init -y
-```
-
-## What It Does
-
-1. Creates `.taskmaster/` directory structure
-2. Initializes empty `tasks.json`
-3. Sets up default configuration
-4. Uses directory name as project name
-5. Skips all confirmation prompts
-
-## Smart Defaults
-
-- Project name: Current directory name
-- Description: "Task Master Project"
-- Model config: Existing environment vars
-- Task structure: Standard format
-
-## Next Steps
-
-After quick init:
-1. Configure AI models if needed:
-   ```
-   /project:tm/models/setup
-   ```
-
-2. Parse PRD if available:
-   ```
-   /project:tm/parse-prd <file>
-   ```
-
-3. Or create first task:
-   ```
-   /project:tm/add-task create initial setup
-   ```
-
-Perfect for rapid project setup!

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

@@ -1,62 +0,0 @@
-Remove a dependency between tasks.
-
-Arguments: $ARGUMENTS
-
-Parse the task IDs to remove dependency relationship.
-
-## Removing Dependencies
-
-Removes a dependency relationship, potentially unblocking tasks.
-
-## Argument Parsing
-
-Parse natural language or IDs:
-- "remove dependency between 5 and 3"
-- "5 no longer needs 3"
-- "unblock 5 from 3"
-- "5 3" → remove dependency of 5 on 3
-
-## Execution
-
-```bash
-task-master remove-dependency --id=<task-id> --depends-on=<dependency-id>
-```
-
-## Pre-Removal Checks
-
-1. **Verify dependency exists**
-2. **Check impact on task flow**
-3. **Warn if it breaks logical sequence**
-4. **Show what will be unblocked**
-
-## Smart Analysis
-
-Before removing:
-- Show why dependency might have existed
-- Check if removal makes tasks executable
-- Verify no critical path disruption
-- Suggest alternative dependencies
-
-## Post-Removal
-
-After removing:
-1. Show updated task status
-2. List newly unblocked tasks
-3. Update project timeline
-4. Suggest next actions
-
-## Safety Features
-
-- Confirm if removing critical dependency
-- Show tasks that become immediately actionable
-- Warn about potential issues
-- Keep removal history
-
-## Example
-
-```
-/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/tm-main.md

@@ -1,146 +0,0 @@
-# Task Master Command Reference
-
-Comprehensive command structure for Task Master integration with Claude Code.
-
-## Command Organization
-
-Commands are organized hierarchically to match Task Master's CLI structure while providing enhanced Claude Code integration.
-
-## Project Setup & Configuration
-
-### `/project:tm/init`
-- `init-project` - Initialize new project (handles PRD files intelligently)
-- `init-project-quick` - Quick setup with auto-confirmation (-y flag)
-
-### `/project:tm/models`
-- `view-models` - View current AI model configuration
-- `setup-models` - Interactive model configuration
-- `set-main` - Set primary generation model
-- `set-research` - Set research model
-- `set-fallback` - Set fallback model
-
-## Task Generation
-
-### `/project:tm/parse-prd`
-- `parse-prd` - Generate tasks from PRD document
-- `parse-prd-with-research` - Enhanced parsing with research mode
-
-### `/project:tm/generate`
-- `generate-tasks` - Create individual task files from tasks.json
-
-## Task Management
-
-### `/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
-
-### `/project:tm/set-status`
-- `to-pending` - Reset task to pending
-- `to-in-progress` - Start working on task
-- `to-done` - Mark task complete
-- `to-review` - Submit for review
-- `to-deferred` - Defer task
-- `to-cancelled` - Cancel task
-
-### `/project:tm/sync-readme`
-- `sync-readme` - Export tasks to README.md with formatting
-
-### `/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
-
-### `/project:tm/add-task`
-- `add-task` - Add new task with AI assistance
-
-### `/project:tm/remove-task`
-- `remove-task` - Remove task with confirmation
-
-## Subtask Management
-
-### `/project:tm/add-subtask`
-- `add-subtask` - Add new subtask to parent
-- `convert-task-to-subtask` - Convert existing task to subtask
-
-### `/project:tm/remove-subtask`
-- `remove-subtask` - Remove subtask (with optional conversion)
-
-### `/project:tm/clear-subtasks`
-- `clear-subtasks` - Clear subtasks from specific task
-- `clear-all-subtasks` - Clear all subtasks globally
-
-## Task Analysis & Breakdown
-
-### `/project:tm/analyze-complexity`
-- `analyze-complexity` - Analyze and generate expansion recommendations
-
-### `/project:tm/complexity-report`
-- `complexity-report` - Display complexity analysis report
-
-### `/project:tm/expand`
-- `expand-task` - Break down specific task
-- `expand-all-tasks` - Expand all eligible tasks
-- `with-research` - Enhanced expansion
-
-## Task Navigation
-
-### `/project:tm/next`
-- `next-task` - Intelligent next task recommendation
-
-### `/project:tm/show`
-- `show-task` - Display detailed task information
-
-### `/project:tm/status`
-- `project-status` - Comprehensive project dashboard
-
-## Dependency Management
-
-### `/project:tm/add-dependency`
-- `add-dependency` - Add task dependency
-
-### `/project:tm/remove-dependency`
-- `remove-dependency` - Remove task dependency
-
-### `/project:tm/validate-dependencies`
-- `validate-dependencies` - Check for dependency issues
-
-### `/project:tm/fix-dependencies`
-- `fix-dependencies` - Automatically fix dependency problems
-
-## Workflows & Automation
-
-### `/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
-
-### `/project:tm/utils`
-- `analyze-project` - Deep project analysis and insights
-
-### `/project:tm/setup`
-- `install-taskmaster` - Comprehensive installation guide
-- `quick-install-taskmaster` - One-line global installation
-
-## Usage Patterns
-
-### Natural Language
-Most commands accept natural language arguments:
-```
-/project:tm/add-task create user authentication system
-/project:tm/update mark all API tasks as high priority
-/project:tm/list show blocked tasks
-```
-
-### ID-Based Commands
-Commands requiring IDs intelligently parse from $ARGUMENTS:
-```
-/project:tm/show 45
-/project:tm/expand 23
-/project:tm/set-status/to-done 67
-```
-
-### Smart Defaults
-Commands provide intelligent defaults and suggestions based on context.

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

@@ -1,119 +0,0 @@
-Update a single specific task with new information.
-
-Arguments: $ARGUMENTS
-
-Parse task ID and update details.
-
-## Single Task Update
-
-Precisely update one task with AI assistance to maintain consistency.
-
-## Argument Parsing
-
-Natural language updates:
-- "5: add caching requirement"
-- "update 5 to include error handling"
-- "task 5 needs rate limiting"
-- "5 change priority to high"
-
-## Execution
-
-```bash
-task-master update-task --id=<id> --prompt="<context>"
-```
-
-## Update Types
-
-### 1. **Content Updates**
-- Enhance description
-- Add requirements
-- Clarify details
-- Update acceptance criteria
-
-### 2. **Metadata Updates**
-- Change priority
-- Adjust time estimates
-- Update complexity
-- Modify dependencies
-
-### 3. **Strategic Updates**
-- Revise approach
-- Change test strategy
-- Update implementation notes
-- Adjust subtask needs
-
-## AI-Powered Updates
-
-The AI:
-1. **Understands Context**
-   - Reads current task state
-   - Identifies update intent
-   - Maintains consistency
-   - Preserves important info
-
-2. **Applies Changes**
-   - Updates relevant fields
-   - Keeps style consistent
-   - Adds without removing
-   - Enhances clarity
-
-3. **Validates Results**
-   - Checks coherence
-   - Verifies completeness
-   - Maintains relationships
-   - Suggests related updates
-
-## Example Updates
-
-```
-/project:tm/update/single 5: add rate limiting
-→ Updating Task #5: "Implement API endpoints"
-
-Current: Basic CRUD endpoints
-Adding: Rate limiting requirements
-
-Updated sections:
-✓ Description: Added rate limiting mention
-✓ Details: Added specific limits (100/min)
-✓ Test Strategy: Added rate limit tests
-✓ Complexity: Increased from 5 to 6
-✓ Time Estimate: Increased by 2 hours
-
-Suggestion: Also update task #6 (API Gateway) for consistency?
-```
-
-## Smart Features
-
-1. **Incremental Updates**
-   - Adds without overwriting
-   - Preserves work history
-   - Tracks what changed
-   - Shows diff view
-
-2. **Consistency Checks**
-   - Related task alignment
-   - Subtask compatibility
-   - Dependency validity
-   - Timeline impact
-
-3. **Update History**
-   - Timestamp changes
-   - Track who/what updated
-   - Reason for update
-   - Previous versions
-
-## Field-Specific Updates
-
-Quick syntax for specific fields:
-- "5 priority:high" → Update priority only
-- "5 add-time:4h" → Add to time estimate
-- "5 status:review" → Change status
-- "5 depends:3,4" → Add dependencies
-
-## Post-Update
-
-- Show updated task
-- Highlight changes
-- Check related tasks
-- Update suggestions
-- Timeline adjustments

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

@@ -1,108 +0,0 @@
-Update multiple tasks starting from a specific ID.
-
-Arguments: $ARGUMENTS
-
-Parse starting task ID and update context.
-
-## Bulk Task Updates
-
-Update multiple related tasks based on new requirements or context changes.
-
-## Argument Parsing
-
-- "from 5: add security requirements"
-- "5 onwards: update API endpoints"
-- "starting at 5: change to use new framework"
-
-## Execution
-
-```bash
-task-master update --from=<id> --prompt="<context>"
-```
-
-## Update Process
-
-### 1. **Task Selection**
-Starting from specified ID:
-- Include the task itself
-- Include all dependent tasks
-- Include related subtasks
-- Smart boundary detection
-
-### 2. **Context Application**
-AI analyzes the update context and:
-- Identifies what needs changing
-- Maintains consistency
-- Preserves completed work
-- Updates related information
-
-### 3. **Intelligent Updates**
-- Modify descriptions appropriately
-- Update test strategies
-- Adjust time estimates
-- Revise dependencies if needed
-
-## Smart Features
-
-1. **Scope Detection**
-   - Find natural task groupings
-   - Identify related features
-   - Stop at logical boundaries
-   - Avoid over-updating
-
-2. **Consistency Maintenance**
-   - Keep naming conventions
-   - Preserve relationships
-   - Update cross-references
-   - Maintain task flow
-
-3. **Change Preview**
-   ```
-   Bulk Update Preview
-   ━━━━━━━━━━━━━━━━━━
-   Starting from: Task #5
-   Tasks to update: 8 tasks + 12 subtasks
-   
-   Context: "add security requirements"
-   
-   Changes will include:
-   - Add security sections to descriptions
-   - Update test strategies for security
-   - Add security-related subtasks where needed
-   - Adjust time estimates (+20% average)
-   
-   Continue? (y/n)
-   ```
-
-## Example Updates
-
-```
-/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
-→ Preview changes? (y/n)
-
-Applied updates:
-✓ Task #5: Updated connection logic references
-✓ Task #6: Changed migration approach
-✓ Task #7: Updated query syntax notes
-✓ Task #8: Revised testing strategy
-✓ Task #9: Updated deployment steps
-✓ Task #12: Changed backup procedures
-```
-
-## Safety Features
-
-- Preview all changes
-- Selective confirmation
-- Rollback capability
-- Change logging
-- Validation checks
-
-## Post-Update
-
-- Summary of changes
-- Consistency verification
-- Suggest review tasks
-- Update timeline if needed

.coderabbit.yaml

@@ -1,10 +1,7 @@
 reviews:
-  profile: assertive
+  profile: chill
   poem: false
   auto_review:
+    enabled: true
     base_branches:
-      - rc
-      - beta
-      - alpha
-      - production
-      - next
+      - ".*"

.cursor/mcp.json

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

.cursor/rules/test_workflow.mdc

@@ -0,0 +1,803 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+# Test Workflow & Development Process
+
+## **Initial Testing Framework Setup**
+
+Before implementing the TDD workflow, ensure your project has a proper testing framework configured. This section covers setup for different technology stacks.
+
+### **Detecting Project Type & Framework Needs**
+
+**AI Agent Assessment Checklist:**
+1. **Language Detection**: Check for `package.json` (Node.js/JavaScript), `requirements.txt` (Python), `Cargo.toml` (Rust), etc.
+2. **Existing Tests**: Look for test files (`.test.`, `.spec.`, `_test.`) or test directories
+3. **Framework Detection**: Check for existing test runners in dependencies
+4. **Project Structure**: Analyze directory structure for testing patterns
+
+### **JavaScript/Node.js Projects (Jest Setup)**
+
+#### **Prerequisites Check**
+```bash
+# Verify Node.js project
+ls package.json  # Should exist
+
+# Check for existing testing setup
+ls jest.config.js jest.config.ts  # Check for Jest config
+grep -E "(jest|vitest|mocha)" package.json  # Check for test runners
+```
+
+#### **Jest Installation & Configuration**
+
+**Step 1: Install Dependencies**
+```bash
+# Core Jest dependencies
+npm install --save-dev jest
+
+# TypeScript support (if using TypeScript)
+npm install --save-dev ts-jest @types/jest
+
+# Additional useful packages
+npm install --save-dev supertest @types/supertest  # For API testing
+npm install --save-dev jest-watch-typeahead  # Enhanced watch mode
+```
+
+**Step 2: Create Jest Configuration**
+
+Create `jest.config.js` with the following production-ready configuration:
+
+```javascript
+/** @type {import('jest').Config} */
+module.exports = {
+  // Use ts-jest preset for TypeScript support
+  preset: 'ts-jest',
+
+  // Test environment
+  testEnvironment: 'node',
+
+  // Roots for test discovery
+  roots: ['<rootDir>/src', '<rootDir>/tests'],
+
+  // Test file patterns
+  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
+
+  // Transform files
+  transform: {
+    '^.+\\.ts$': [
+      'ts-jest',
+      {
+        tsconfig: {
+          target: 'es2020',
+          module: 'commonjs',
+          esModuleInterop: true,
+          allowSyntheticDefaultImports: true,
+          skipLibCheck: true,
+          strict: false,
+          noImplicitAny: false,
+        },
+      },
+    ],
+    '^.+\\.js$': [
+      'ts-jest',
+      {
+        useESM: false,
+        tsconfig: {
+          target: 'es2020',
+          module: 'commonjs',
+          esModuleInterop: true,
+          allowSyntheticDefaultImports: true,
+          allowJs: true,
+        },
+      },
+    ],
+  },
+
+  // Module file extensions
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+
+  // Transform ignore patterns - adjust for ES modules
+  transformIgnorePatterns: ['node_modules/(?!(your-es-module-deps|.*\\.mjs$))'],
+
+  // Coverage configuration
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: [
+    'text', // Console output
+    'text-summary', // Brief summary
+    'lcov', // For IDE integration
+    'html', // Detailed HTML report
+  ],
+
+  // Files to collect coverage from
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/*.test.ts',
+    '!src/**/index.ts', // Often just exports
+    '!src/generated/**', // Generated code
+    '!src/config/database.ts', // Database config (tested via integration)
+  ],
+
+  // Coverage thresholds - TaskMaster standards
+  coverageThreshold: {
+    global: {
+      branches: 70,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+    // Higher standards for critical business logic
+    './src/utils/': {
+      branches: 85,
+      functions: 90,
+      lines: 90,
+      statements: 90,
+    },
+    './src/middleware/': {
+      branches: 80,
+      functions: 85,
+      lines: 85,
+      statements: 85,
+    },
+  },
+
+  // Setup files
+  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
+
+  // Global teardown to prevent worker process leaks
+  globalTeardown: '<rootDir>/tests/teardown.ts',
+
+  // Module path mapping (if needed)
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+
+  // Clear mocks between tests
+  clearMocks: true,
+
+  // Restore mocks after each test
+  restoreMocks: true,
+
+  // Global test timeout
+  testTimeout: 10000,
+
+  // Projects for different test types
+  projects: [
+    // Unit tests - for pure functions only
+    {
+      displayName: 'unit',
+      testMatch: ['<rootDir>/src/**/*.test.ts'],
+      testPathIgnorePatterns: ['.*\\.integration\\.test\\.ts$', '/tests/'],
+      preset: 'ts-jest',
+      testEnvironment: 'node',
+      collectCoverageFrom: [
+        'src/**/*.ts',
+        '!src/**/*.d.ts',
+        '!src/**/*.test.ts',
+        '!src/**/*.integration.test.ts',
+      ],
+      coverageThreshold: {
+        global: {
+          branches: 70,
+          functions: 80,
+          lines: 80,
+          statements: 80,
+        },
+      },
+    },
+    // Integration tests - real database/services
+    {
+      displayName: 'integration',
+      testMatch: [
+        '<rootDir>/src/**/*.integration.test.ts',
+        '<rootDir>/tests/integration/**/*.test.ts',
+      ],
+      preset: 'ts-jest',
+      testEnvironment: 'node',
+      setupFilesAfterEnv: ['<rootDir>/tests/setup/integration.ts'],
+      testTimeout: 10000,
+    },
+    // E2E tests - full workflows
+    {
+      displayName: 'e2e',
+      testMatch: ['<rootDir>/tests/e2e/**/*.test.ts'],
+      preset: 'ts-jest',
+      testEnvironment: 'node',
+      setupFilesAfterEnv: ['<rootDir>/tests/setup/e2e.ts'],
+      testTimeout: 30000,
+    },
+  ],
+
+  // Verbose output for better debugging
+  verbose: true,
+
+  // Run projects sequentially to avoid conflicts
+  maxWorkers: 1,
+
+  // Enable watch mode plugins
+  watchPlugins: ['jest-watch-typeahead/filename', 'jest-watch-typeahead/testname'],
+};
+```
+
+**Step 3: Update package.json Scripts**
+
+Add these scripts to your `package.json`:
+
+```json
+{
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:unit": "jest --selectProjects unit",
+    "test:integration": "jest --selectProjects integration", 
+    "test:e2e": "jest --selectProjects e2e",
+    "test:ci": "jest --ci --coverage --watchAll=false"
+  }
+}
+```
+
+**Step 4: Create Test Setup Files**
+
+Create essential test setup files:
+
+```typescript
+// tests/setup.ts - Global setup
+import { jest } from '@jest/globals';
+
+// Global test configuration
+beforeAll(() => {
+  // Set test timeout
+  jest.setTimeout(10000);
+});
+
+afterEach(() => {
+  // Clean up mocks after each test
+  jest.clearAllMocks();
+});
+```
+
+```typescript
+// tests/setup/integration.ts - Integration test setup
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+beforeAll(async () => {
+  // Connect to test database
+  await prisma.$connect();
+});
+
+afterAll(async () => {
+  // Cleanup and disconnect
+  await prisma.$disconnect();
+});
+
+beforeEach(async () => {
+  // Clean test data before each test
+  // Add your cleanup logic here
+});
+```
+
+```typescript
+// tests/teardown.ts - Global teardown
+export default async () => {
+  // Global cleanup after all tests
+  console.log('Global test teardown complete');
+};
+```
+
+**Step 5: Create Initial Test Structure**
+
+```bash
+# Create test directories
+mkdir -p tests/{setup,fixtures,unit,integration,e2e}
+mkdir -p tests/unit/src/{utils,services,middleware}
+
+# Create sample test fixtures
+mkdir tests/fixtures
+```
+
+### **Generic Testing Framework Setup (Any Language)**
+
+#### **Framework Selection Guide**
+
+**Python Projects:**
+- **pytest**: Recommended for most Python projects
+- **unittest**: Built-in, suitable for simple projects
+- **Coverage**: Use `coverage.py` for code coverage
+
+```bash
+# Python setup example
+pip install pytest pytest-cov
+echo "[tool:pytest]" > pytest.ini
+echo "testpaths = tests" >> pytest.ini
+echo "addopts = --cov=src --cov-report=html --cov-report=term" >> pytest.ini
+```
+
+**Go Projects:**
+- **Built-in testing**: Use Go's built-in `testing` package
+- **Coverage**: Built-in with `go test -cover`
+
+```bash
+# Go setup example
+go mod init your-project
+mkdir -p tests
+# Tests are typically *_test.go files alongside source
+```
+
+**Rust Projects:**
+- **Built-in testing**: Use Rust's built-in test framework
+- **cargo-tarpaulin**: For coverage analysis
+
+```bash
+# Rust setup example
+cargo new your-project
+cd your-project
+cargo install cargo-tarpaulin  # For coverage
+```
+
+**Java Projects:**
+- **JUnit 5**: Modern testing framework
+- **Maven/Gradle**: Build tools with testing integration
+
+```xml
+<!-- Maven pom.xml example -->
+<dependency>
+    <groupId>org.junit.jupiter</groupId>
+    <artifactId>junit-jupiter</artifactId>
+    <version>5.9.2</version>
+    <scope>test</scope>
+</dependency>
+```
+
+#### **Universal Testing Principles**
+
+**Coverage Standards (Adapt to Your Language):**
+- **Global Minimum**: 70-80% line coverage
+- **Critical Code**: 85-90% coverage
+- **New Features**: Must meet or exceed standards
+- **Legacy Code**: Gradual improvement strategy
+
+**Test Organization:**
+- **Unit Tests**: Fast, isolated, no external dependencies
+- **Integration Tests**: Test component interactions
+- **E2E Tests**: Test complete user workflows
+- **Performance Tests**: Load and stress testing (if applicable)
+
+**Naming Conventions:**
+- **Test Files**: `*.test.*`, `*_test.*`, or language-specific patterns
+- **Test Functions**: Descriptive names (e.g., `should_return_error_for_invalid_input`)
+- **Test Directories**: Organized by test type and mirroring source structure
+
+#### **TaskMaster Integration for Any Framework**
+
+**Document Testing Setup in Subtasks:**
+```bash
+# Update subtask with testing framework setup
+task-master update-subtask --id=X.Y --prompt="Testing framework setup:
+- Installed [Framework Name] with coverage support
+- Configured [Coverage Tool] with thresholds: 80% lines, 70% branches
+- Created test directory structure: unit/, integration/, e2e/
+- Added test scripts to build configuration
+- All setup tests passing"
+```
+
+**Testing Framework Verification:**
+```bash
+# Verify setup works
+[test-command]  # e.g., npm test, pytest, go test, cargo test
+
+# Check coverage reporting
+[coverage-command]  # e.g., npm run test:coverage
+
+# Update task with verification
+task-master update-subtask --id=X.Y --prompt="Testing framework verified:
+- Sample tests running successfully
+- Coverage reporting functional
+- CI/CD integration ready
+- Ready to begin TDD workflow"
+```
+
+## **Test-Driven Development (TDD) Integration**
+
+### **Core TDD Cycle with Jest**
+```bash
+# 1. Start development with watch mode
+npm run test:watch
+
+# 2. Write failing test first
+# Create test file: src/utils/newFeature.test.ts
+# Write test that describes expected behavior
+
+# 3. Implement minimum code to make test pass
+# 4. Refactor while keeping tests green
+# 5. Add edge cases and error scenarios
+```
+
+### **TDD Workflow Per Subtask**
+```bash
+# When starting a new subtask:
+task-master set-status --id=4.1 --status=in-progress
+
+# Begin TDD cycle:
+npm run test:watch  # Keep running during development
+
+# Document TDD progress in subtask:
+task-master update-subtask --id=4.1 --prompt="TDD Progress:
+- Written 3 failing tests for core functionality
+- Implemented basic feature, tests now passing
+- Adding edge case tests for error handling"
+
+# Complete subtask with test summary:
+task-master update-subtask --id=4.1 --prompt="Implementation complete:
+- Feature implemented with 8 unit tests
+- Coverage: 95% statements, 88% branches  
+- All tests passing, TDD cycle complete"
+```
+
+## **Testing Commands & Usage**
+
+### **Development Commands**
+```bash
+# Primary development command - use during coding
+npm run test:watch              # Watch mode with Jest
+npm run test:watch -- --testNamePattern="auth"  # Watch specific tests
+
+# Targeted testing during development
+npm run test:unit               # Run only unit tests
+npm run test:unit -- --coverage # Unit tests with coverage
+
+# Integration testing when APIs are ready
+npm run test:integration        # Run integration tests
+npm run test:integration -- --detectOpenHandles  # Debug hanging tests
+
+# End-to-end testing for workflows
+npm run test:e2e               # Run E2E tests
+npm run test:e2e -- --timeout=30000  # Extended timeout for E2E
+```
+
+### **Quality Assurance Commands**
+```bash
+# Full test suite with coverage (before commits)
+npm run test:coverage          # Complete coverage analysis
+
+# All tests (CI/CD pipeline)
+npm test                       # Run all test projects
+
+# Specific test file execution
+npm test -- auth.test.ts       # Run specific test file
+npm test -- --testNamePattern="should handle errors"  # Run specific tests
+```
+
+## **Test Implementation Patterns**
+
+### **Unit Test Development**
+```typescript
+// ✅ DO: Follow established patterns from auth.test.ts
+describe('FeatureName', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Setup mocks with proper typing
+  });
+
+  describe('functionName', () => {
+    it('should handle normal case', () => {
+      // Test implementation with specific assertions
+    });
+    
+    it('should throw error for invalid input', async () => {
+      // Error scenario testing
+      await expect(functionName(invalidInput))
+        .rejects.toThrow('Specific error message');
+    });
+  });
+});
+```
+
+### **Integration Test Development**  
+```typescript
+// ✅ DO: Use supertest for API endpoint testing
+import request from 'supertest';
+import { app } from '../../src/app';
+
+describe('POST /api/auth/register', () => {
+  beforeEach(async () => {
+    await integrationTestUtils.cleanupTestData();
+  });
+  
+  it('should register user successfully', async () => {
+    const userData = createTestUser();
+    
+    const response = await request(app)
+      .post('/api/auth/register')
+      .send(userData)
+      .expect(201);
+      
+    expect(response.body).toMatchObject({
+      id: expect.any(String),
+      email: userData.email
+    });
+    
+    // Verify database state
+    const user = await prisma.user.findUnique({
+      where: { email: userData.email }
+    });
+    expect(user).toBeTruthy();
+  });
+});
+```
+
+### **E2E Test Development**
+```typescript
+// ✅ DO: Test complete user workflows
+describe('User Authentication Flow', () => {
+  it('should complete registration → login → protected access', async () => {
+    // Step 1: Register
+    const userData = createTestUser();
+    await request(app)
+      .post('/api/auth/register')
+      .send(userData)
+      .expect(201);
+    
+    // Step 2: Login
+    const loginResponse = await request(app)
+      .post('/api/auth/login')
+      .send({ email: userData.email, password: userData.password })
+      .expect(200);
+    
+    const { token } = loginResponse.body;
+    
+    // Step 3: Access protected resource
+    await request(app)
+      .get('/api/profile')
+      .set('Authorization', `Bearer ${token}`)
+      .expect(200);
+  }, 30000); // Extended timeout for E2E
+});
+```
+
+## **Mocking & Test Utilities**
+
+### **Established Mocking Patterns**
+```typescript
+// ✅ DO: Use established bcrypt mocking pattern
+jest.mock('bcrypt');
+import bcrypt from 'bcrypt';
+const mockHash = bcrypt.hash as jest.MockedFunction<typeof bcrypt.hash>;
+const mockCompare = bcrypt.compare as jest.MockedFunction<typeof bcrypt.compare>;
+
+// ✅ DO: Use Prisma mocking for unit tests
+jest.mock('@prisma/client', () => ({
+  PrismaClient: jest.fn().mockImplementation(() => ({
+    user: {
+      create: jest.fn(),
+      findUnique: jest.fn(),
+    },
+    $connect: jest.fn(),
+    $disconnect: jest.fn(),
+  })),
+}));
+```
+
+### **Test Fixtures Usage**
+```typescript
+// ✅ DO: Use centralized test fixtures
+import { createTestUser, adminUser, invalidUser } from '../fixtures/users';
+
+describe('User Service', () => {
+  it('should handle admin user creation', async () => {
+    const userData = createTestUser(adminUser);
+    // Test implementation
+  });
+  
+  it('should reject invalid user data', async () => {
+    const userData = createTestUser(invalidUser);
+    // Error testing
+  });
+});
+```
+
+## **Coverage Standards & Monitoring**
+
+### **Coverage Thresholds**
+- **Global Standards**: 80% lines/functions, 70% branches
+- **Critical Code**: 90% utils, 85% middleware
+- **New Features**: Must meet or exceed global thresholds
+- **Legacy Code**: Gradual improvement with each change
+
+### **Coverage Reporting & Analysis**
+```bash
+# Generate coverage reports
+npm run test:coverage
+
+# View detailed HTML report
+open coverage/lcov-report/index.html
+
+# Coverage files generated:
+# - coverage/lcov-report/index.html  # Detailed HTML report
+# - coverage/lcov.info               # LCOV format for IDE integration  
+# - coverage/coverage-final.json     # JSON format for tooling
+```
+
+### **Coverage Quality Checks**
+```typescript
+// ✅ DO: Test all code paths
+describe('validateInput', () => {
+  it('should return true for valid input', () => {
+    expect(validateInput('valid')).toBe(true);
+  });
+  
+  it('should return false for various invalid inputs', () => {
+    expect(validateInput('')).toBe(false);      // Empty string
+    expect(validateInput(null)).toBe(false);    // Null value
+    expect(validateInput(undefined)).toBe(false); // Undefined
+  });
+  
+  it('should throw for unexpected input types', () => {
+    expect(() => validateInput(123)).toThrow('Invalid input type');
+  });
+});
+```
+
+## **Testing During Development Phases**
+
+### **Feature Development Phase**
+```bash
+# 1. Start feature development
+task-master set-status --id=X.Y --status=in-progress
+
+# 2. Begin TDD cycle  
+npm run test:watch
+
+# 3. Document test progress in subtask
+task-master update-subtask --id=X.Y --prompt="Test development:
+- Created test file with 5 failing tests
+- Implemented core functionality
+- Tests passing, adding error scenarios"
+
+# 4. Verify coverage before completion
+npm run test:coverage
+
+# 5. Update subtask with final test status
+task-master update-subtask --id=X.Y --prompt="Testing complete:
+- 12 unit tests with full coverage
+- All edge cases and error scenarios covered
+- Ready for integration testing"
+```
+
+### **Integration Testing Phase**
+```bash
+# After API endpoints are implemented
+npm run test:integration
+
+# Update integration test templates
+# Replace placeholder tests with real endpoint calls
+
+# Document integration test results
+task-master update-subtask --id=X.Y --prompt="Integration tests:
+- Updated auth endpoint tests  
+- Database integration verified
+- All HTTP status codes and responses tested"
+```
+
+### **Pre-Commit Testing Phase**
+```bash
+# Before committing code
+npm run test:coverage         # Verify all tests pass with coverage
+npm run test:unit            # Quick unit test verification
+npm run test:integration     # Integration test verification (if applicable)
+
+# Commit pattern for test updates
+git add tests/ src/**/*.test.ts
+git commit -m "test(task-X): Add comprehensive tests for Feature Y
+
+- Unit tests with 95% coverage (exceeds 90% threshold)
+- Integration tests for API endpoints
+- Test fixtures for data generation
+- Proper mocking patterns established
+
+Task X: Feature Y - Testing complete"
+```
+
+## **Error Handling & Debugging**
+
+### **Test Debugging Techniques**
+```typescript
+// ✅ DO: Use test utilities for debugging
+import { testUtils } from '../setup';
+
+it('should debug complex operation', () => {
+  testUtils.withConsole(() => {
+    // Console output visible only for this test
+    console.log('Debug info:', complexData);
+    service.complexOperation();
+  });
+});
+
+// ✅ DO: Use proper async debugging
+it('should handle async operations', async () => {
+  const promise = service.asyncOperation();
+  
+  // Test intermediate state
+  expect(service.isProcessing()).toBe(true);
+  
+  const result = await promise;
+  expect(result).toBe('expected');
+  expect(service.isProcessing()).toBe(false);
+});
+```
+
+### **Common Test Issues & Solutions**
+```bash
+# Hanging tests (common with database connections)
+npm run test:integration -- --detectOpenHandles
+
+# Memory leaks in tests
+npm run test:unit -- --logHeapUsage
+
+# Slow tests identification
+npm run test:coverage -- --verbose
+
+# Mock not working properly
+# Check: mock is declared before imports
+# Check: jest.clearAllMocks() in beforeEach
+# Check: TypeScript typing is correct
+```
+
+## **Continuous Integration Integration**
+
+### **CI/CD Pipeline Testing**
+```yaml
+# Example GitHub Actions integration
+- name: Run tests
+  run: |
+    npm ci
+    npm run test:coverage
+    
+- name: Upload coverage reports
+  uses: codecov/codecov-action@v3
+  with:
+    file: ./coverage/lcov.info
+```
+
+### **Pre-commit Hooks**
+```bash
+# Setup pre-commit testing (recommended)
+# In package.json scripts:
+"pre-commit": "npm run test:unit && npm run test:integration"
+
+# Husky integration example:
+npx husky add .husky/pre-commit "npm run test:unit"
+```
+
+## **Test Maintenance & Evolution**
+
+### **Adding Tests for New Features**
+1. **Create test file** alongside source code or in `tests/unit/`
+2. **Follow established patterns** from `src/utils/auth.test.ts`
+3. **Use existing fixtures** from `tests/fixtures/`
+4. **Apply proper mocking** patterns for dependencies
+5. **Meet coverage thresholds** for the module
+
+### **Updating Integration/E2E Tests**
+1. **Update templates** in `tests/integration/` when APIs change
+2. **Modify E2E workflows** in `tests/e2e/` for new user journeys  
+3. **Update test fixtures** for new data requirements
+4. **Maintain database cleanup** utilities
+
+### **Test Performance Optimization**
+- **Parallel execution**: Jest runs tests in parallel by default
+- **Test isolation**: Use proper setup/teardown for independence
+- **Mock optimization**: Mock heavy dependencies appropriately  
+- **Database efficiency**: Use transaction rollbacks where possible
+
+---
+
+**Key References:**
+- [Testing Standards](mdc:.cursor/rules/tests.mdc)
+- [Git Workflow](mdc:.cursor/rules/git_workflow.mdc)
+- [Development Workflow](mdc:.cursor/rules/dev_workflow.mdc)
+- [Jest Configuration](mdc:jest.config.js)

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,45 @@
+# What type of PR is this?
+<!-- Check one -->
+
+ - [ ] 🐛 Bug fix
+ - [ ] ✨ Feature
+ - [ ] 🔌 Integration
+ - [ ] 📝 Docs
+ - [ ] 🧹 Refactor
+ - [ ] Other:
+## Description
+<!-- What does this PR do? -->
+
+## Related Issues
+<!-- Link issues: Fixes #123 -->
+
+## How to Test This
+<!-- Quick steps to verify the changes work -->
+```bash
+# Example commands or steps
+```
+
+**Expected result:**
+<!-- What should happen? -->
+
+## Contributor Checklist
+
+- [ ] Created changeset: `npm run changeset`
+- [ ] Tests pass: `npm test`
+- [ ] Format check passes: `npm run format-check` (or `npm run format` to fix)
+- [ ] Addressed CodeRabbit comments (if any)
+- [ ] Linked related issues (if any)
+- [ ] Manually tested the changes
+
+## Changelog Entry
+<!-- One line describing the change for users -->
+<!-- Example: "Added Kiro IDE integration with automatic task status updates" -->
+
+---
+
+### For Maintainers
+
+- [ ] PR title follows conventional commits
+- [ ] Target branch correct
+- [ ] Labels added
+- [ ] Milestone assigned (if applicable)

.github/PULL_REQUEST_TEMPLATE/bugfix.md

@@ -0,0 +1,39 @@
+## 🐛 Bug Fix
+
+### 🔍 Bug Description
+<!-- Describe the bug -->
+
+### 🔗 Related Issues
+<!-- Fixes #123 -->
+
+### ✨ Solution
+<!-- How does this PR fix the bug? -->
+
+## How to Test
+
+### Steps that caused the bug:
+1. 
+2. 
+
+**Before fix:** 
+**After fix:** 
+
+### Quick verification:
+```bash
+# Commands to verify the fix
+```
+
+## Contributor Checklist
+- [ ] Created changeset: `npm run changeset`
+- [ ] Tests pass: `npm test`
+- [ ] Format check passes: `npm run format-check`
+- [ ] Addressed CodeRabbit comments
+- [ ] Added unit tests (if applicable)
+- [ ] Manually verified the fix works
+
+---
+
+### For Maintainers
+- [ ] Root cause identified
+- [ ] Fix doesn't introduce new issues
+- [ ] CI passes

.github/PULL_REQUEST_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 🐛 Bug Fix
+    url: https://github.com/eyaltoledano/claude-task-master/compare/next...HEAD?template=bugfix.md
+    about: Fix a bug in Task Master
+  - name: ✨ New Feature
+    url: https://github.com/eyaltoledano/claude-task-master/compare/next...HEAD?template=feature.md
+    about: Add a new feature to Task Master
+  - name: 🔌 New Integration
+    url: https://github.com/eyaltoledano/claude-task-master/compare/next...HEAD?template=integration.md
+    about: Add support for a new tool, IDE, or platform

.github/PULL_REQUEST_TEMPLATE/feature.md

@@ -0,0 +1,49 @@
+## ✨ New Feature
+
+### 📋 Feature Description
+<!-- Brief description -->
+
+### 🎯 Problem Statement
+<!-- What problem does this feature solve? Why is it needed? -->
+
+### 💡 Solution
+<!-- How does this feature solve the problem? What's the approach? -->
+
+### 🔗 Related Issues
+<!-- Link related issues: Fixes #123, Part of #456 -->
+
+## How to Use It
+
+### Quick Start
+```bash
+# Basic usage example
+```
+
+### Example
+<!-- Show a real use case -->
+```bash
+# Practical example
+```
+
+**What you should see:**
+<!-- Expected behavior -->
+
+## Contributor Checklist
+- [ ] Created changeset: `npm run changeset`
+- [ ] Tests pass: `npm test`
+- [ ] Format check passes: `npm run format-check`
+- [ ] Addressed CodeRabbit comments
+- [ ] Added tests for new functionality
+- [ ] Manually tested in CLI mode
+- [ ] Manually tested in MCP mode (if applicable)
+
+## Changelog Entry
+<!-- One-liner for release notes -->
+
+---
+
+### For Maintainers
+
+- [ ] Feature aligns with project vision
+- [ ] CIs pass
+- [ ] Changeset file exists

.github/PULL_REQUEST_TEMPLATE/integration.md

@@ -0,0 +1,53 @@
+# 🔌 New Integration
+
+## What tool/IDE is being integrated?
+
+<!-- Name and brief description -->
+
+## What can users do with it?
+
+<!-- Key benefits -->
+
+## How to Enable
+
+### Setup
+
+```bash
+task-master rules add [name]
+# Any other setup steps
+```
+
+### Example Usage
+
+<!-- Show it in action -->
+
+```bash
+# Real example
+```
+
+### Natural Language Hooks (if applicable)
+
+```
+"When tests pass, mark task as done"
+# Other examples
+```
+
+## Contributor Checklist
+
+- [ ] Created changeset: `npm run changeset`
+- [ ] Tests pass: `npm test`
+- [ ] Format check passes: `npm run format-check`
+- [ ] Addressed CodeRabbit comments
+- [ ] Integration fully tested with target tool/IDE
+- [ ] Error scenarios tested
+- [ ] Added integration tests
+- [ ] Documentation includes setup guide
+- [ ] Examples are working and clear
+
+---
+
+## For Maintainers
+
+- [ ] Integration stability verified
+- [ ] Documentation comprehensive
+- [ ] Examples working

.github/scripts/auto-close-duplicates.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+
+async function githubRequest(endpoint, token, method = 'GET', body) {
+	const response = await fetch(`https://api.github.com${endpoint}`, {
+		method,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			Accept: 'application/vnd.github.v3+json',
+			'User-Agent': 'auto-close-duplicates-script',
+			...(body && { 'Content-Type': 'application/json' })
+		},
+		...(body && { body: JSON.stringify(body) })
+	});
+
+	if (!response.ok) {
+		throw new Error(
+			`GitHub API request failed: ${response.status} ${response.statusText}`
+		);
+	}
+
+	return response.json();
+}
+
+function extractDuplicateIssueNumber(commentBody) {
+	const match = commentBody.match(/#(\d+)/);
+	return match ? parseInt(match[1], 10) : null;
+}
+
+async function closeIssueAsDuplicate(
+	owner,
+	repo,
+	issueNumber,
+	duplicateOfNumber,
+	token
+) {
+	await githubRequest(
+		`/repos/${owner}/${repo}/issues/${issueNumber}`,
+		token,
+		'PATCH',
+		{
+			state: 'closed',
+			state_reason: 'not_planned',
+			labels: ['duplicate']
+		}
+	);
+
+	await githubRequest(
+		`/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
+		token,
+		'POST',
+		{
+			body: `This issue has been automatically closed as a duplicate of #${duplicateOfNumber}.
+
+If this is incorrect, please re-open this issue or create a new one.
+
+🤖 Generated with [Task Master Bot]`
+		}
+	);
+}
+
+async function autoCloseDuplicates() {
+	console.log('[DEBUG] Starting auto-close duplicates script');
+
+	const token = process.env.GITHUB_TOKEN;
+	if (!token) {
+		throw new Error('GITHUB_TOKEN environment variable is required');
+	}
+	console.log('[DEBUG] GitHub token found');
+
+	const owner = process.env.GITHUB_REPOSITORY_OWNER || 'eyaltoledano';
+	const repo = process.env.GITHUB_REPOSITORY_NAME || 'claude-task-master';
+	console.log(`[DEBUG] Repository: ${owner}/${repo}`);
+
+	const threeDaysAgo = new Date();
+	threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
+	console.log(
+		`[DEBUG] Checking for duplicate comments older than: ${threeDaysAgo.toISOString()}`
+	);
+
+	console.log('[DEBUG] Fetching open issues created more than 3 days ago...');
+	const allIssues = [];
+	let page = 1;
+	const perPage = 100;
+
+	const MAX_PAGES = 50; // Increase limit for larger repos
+	let foundRecentIssue = false;
+
+	while (true) {
+		const pageIssues = await githubRequest(
+			`/repos/${owner}/${repo}/issues?state=open&per_page=${perPage}&page=${page}&sort=created&direction=desc`,
+			token
+		);
+
+		if (pageIssues.length === 0) break;
+
+		// Filter for issues created more than 3 days ago
+		const oldEnoughIssues = pageIssues.filter(
+			(issue) => new Date(issue.created_at) <= threeDaysAgo
+		);
+
+		allIssues.push(...oldEnoughIssues);
+
+		// If all issues on this page are newer than 3 days, we can stop
+		if (oldEnoughIssues.length === 0 && page === 1) {
+			foundRecentIssue = true;
+			break;
+		}
+
+		// If we found some old issues but not all, continue to next page
+		// as there might be more old issues
+		page++;
+
+		// Safety limit to avoid infinite loops
+		if (page > MAX_PAGES) {
+			console.log(`[WARNING] Reached maximum page limit of ${MAX_PAGES}`);
+			break;
+		}
+	}
+
+	const issues = allIssues;
+	console.log(`[DEBUG] Found ${issues.length} open issues`);
+
+	let processedCount = 0;
+	let candidateCount = 0;
+
+	for (const issue of issues) {
+		processedCount++;
+		console.log(
+			`[DEBUG] Processing issue #${issue.number} (${processedCount}/${issues.length}): ${issue.title}`
+		);
+
+		console.log(`[DEBUG] Fetching comments for issue #${issue.number}...`);
+		const comments = await githubRequest(
+			`/repos/${owner}/${repo}/issues/${issue.number}/comments`,
+			token
+		);
+		console.log(
+			`[DEBUG] Issue #${issue.number} has ${comments.length} comments`
+		);
+
+		const dupeComments = comments.filter(
+			(comment) =>
+				comment.body.includes('Found') &&
+				comment.body.includes('possible duplicate') &&
+				comment.user.type === 'Bot'
+		);
+		console.log(
+			`[DEBUG] Issue #${issue.number} has ${dupeComments.length} duplicate detection comments`
+		);
+
+		if (dupeComments.length === 0) {
+			console.log(
+				`[DEBUG] Issue #${issue.number} - no duplicate comments found, skipping`
+			);
+			continue;
+		}
+
+		const lastDupeComment = dupeComments[dupeComments.length - 1];
+		const dupeCommentDate = new Date(lastDupeComment.created_at);
+		console.log(
+			`[DEBUG] Issue #${
+				issue.number
+			} - most recent duplicate comment from: ${dupeCommentDate.toISOString()}`
+		);
+
+		if (dupeCommentDate > threeDaysAgo) {
+			console.log(
+				`[DEBUG] Issue #${issue.number} - duplicate comment is too recent, skipping`
+			);
+			continue;
+		}
+		console.log(
+			`[DEBUG] Issue #${
+				issue.number
+			} - duplicate comment is old enough (${Math.floor(
+				(Date.now() - dupeCommentDate.getTime()) / (1000 * 60 * 60 * 24)
+			)} days)`
+		);
+
+		const commentsAfterDupe = comments.filter(
+			(comment) => new Date(comment.created_at) > dupeCommentDate
+		);
+		console.log(
+			`[DEBUG] Issue #${issue.number} - ${commentsAfterDupe.length} comments after duplicate detection`
+		);
+
+		if (commentsAfterDupe.length > 0) {
+			console.log(
+				`[DEBUG] Issue #${issue.number} - has activity after duplicate comment, skipping`
+			);
+			continue;
+		}
+
+		console.log(
+			`[DEBUG] Issue #${issue.number} - checking reactions on duplicate comment...`
+		);
+		const reactions = await githubRequest(
+			`/repos/${owner}/${repo}/issues/comments/${lastDupeComment.id}/reactions`,
+			token
+		);
+		console.log(
+			`[DEBUG] Issue #${issue.number} - duplicate comment has ${reactions.length} reactions`
+		);
+
+		const authorThumbsDown = reactions.some(
+			(reaction) =>
+				reaction.user.id === issue.user.id && reaction.content === '-1'
+		);
+		console.log(
+			`[DEBUG] Issue #${issue.number} - author thumbs down reaction: ${authorThumbsDown}`
+		);
+
+		if (authorThumbsDown) {
+			console.log(
+				`[DEBUG] Issue #${issue.number} - author disagreed with duplicate detection, skipping`
+			);
+			continue;
+		}
+
+		const duplicateIssueNumber = extractDuplicateIssueNumber(
+			lastDupeComment.body
+		);
+		if (!duplicateIssueNumber) {
+			console.log(
+				`[DEBUG] Issue #${issue.number} - could not extract duplicate issue number from comment, skipping`
+			);
+			continue;
+		}
+
+		candidateCount++;
+		const issueUrl = `https://github.com/${owner}/${repo}/issues/${issue.number}`;
+
+		try {
+			console.log(
+				`[INFO] Auto-closing issue #${issue.number} as duplicate of #${duplicateIssueNumber}: ${issueUrl}`
+			);
+			await closeIssueAsDuplicate(
+				owner,
+				repo,
+				issue.number,
+				duplicateIssueNumber,
+				token
+			);
+			console.log(
+				`[SUCCESS] Successfully closed issue #${issue.number} as duplicate of #${duplicateIssueNumber}`
+			);
+		} catch (error) {
+			console.error(
+				`[ERROR] Failed to close issue #${issue.number} as duplicate: ${error}`
+			);
+		}
+	}
+
+	console.log(
+		`[DEBUG] Script completed. Processed ${processedCount} issues, found ${candidateCount} candidates for auto-close`
+	);
+}
+
+autoCloseDuplicates().catch(console.error);

.github/scripts/backfill-duplicate-comments.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+async function githubRequest(endpoint, token, method = 'GET', body) {
+	const response = await fetch(`https://api.github.com${endpoint}`, {
+		method,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			Accept: 'application/vnd.github.v3+json',
+			'User-Agent': 'backfill-duplicate-comments-script',
+			...(body && { 'Content-Type': 'application/json' })
+		},
+		...(body && { body: JSON.stringify(body) })
+	});
+
+	if (!response.ok) {
+		throw new Error(
+			`GitHub API request failed: ${response.status} ${response.statusText}`
+		);
+	}
+
+	return response.json();
+}
+
+async function triggerDedupeWorkflow(
+	owner,
+	repo,
+	issueNumber,
+	token,
+	dryRun = true
+) {
+	if (dryRun) {
+		console.log(
+			`[DRY RUN] Would trigger dedupe workflow for issue #${issueNumber}`
+		);
+		return;
+	}
+
+	await githubRequest(
+		`/repos/${owner}/${repo}/actions/workflows/claude-dedupe-issues.yml/dispatches`,
+		token,
+		'POST',
+		{
+			ref: 'main',
+			inputs: {
+				issue_number: issueNumber.toString()
+			}
+		}
+	);
+}
+
+async function backfillDuplicateComments() {
+	console.log('[DEBUG] Starting backfill duplicate comments script');
+
+	const token = process.env.GITHUB_TOKEN;
+	if (!token) {
+		throw new Error(`GITHUB_TOKEN environment variable is required
+
+Usage:
+  node .github/scripts/backfill-duplicate-comments.mjs
+
+Environment Variables:
+  GITHUB_TOKEN - GitHub personal access token with repo and actions permissions (required)
+  DRY_RUN - Set to "false" to actually trigger workflows (default: true for safety)
+  DAYS_BACK - How many days back to look for old issues (default: 90)`);
+	}
+	console.log('[DEBUG] GitHub token found');
+
+	const owner = process.env.GITHUB_REPOSITORY_OWNER || 'eyaltoledano';
+	const repo = process.env.GITHUB_REPOSITORY_NAME || 'claude-task-master';
+	const dryRun = process.env.DRY_RUN !== 'false';
+	const daysBack = parseInt(process.env.DAYS_BACK || '90', 10);
+
+	console.log(`[DEBUG] Repository: ${owner}/${repo}`);
+	console.log(`[DEBUG] Dry run mode: ${dryRun}`);
+	console.log(`[DEBUG] Looking back ${daysBack} days`);
+
+	const cutoffDate = new Date();
+	cutoffDate.setDate(cutoffDate.getDate() - daysBack);
+
+	console.log(
+		`[DEBUG] Fetching issues created since ${cutoffDate.toISOString()}...`
+	);
+	const allIssues = [];
+	let page = 1;
+	const perPage = 100;
+
+	while (true) {
+		const pageIssues = await githubRequest(
+			`/repos/${owner}/${repo}/issues?state=all&per_page=${perPage}&page=${page}&since=${cutoffDate.toISOString()}`,
+			token
+		);
+
+		if (pageIssues.length === 0) break;
+
+		allIssues.push(...pageIssues);
+		page++;
+
+		// Safety limit to avoid infinite loops
+		if (page > 100) {
+			console.log('[DEBUG] Reached page limit, stopping pagination');
+			break;
+		}
+	}
+
+	console.log(
+		`[DEBUG] Found ${allIssues.length} issues from the last ${daysBack} days`
+	);
+
+	let processedCount = 0;
+	let candidateCount = 0;
+	let triggeredCount = 0;
+
+	for (const issue of allIssues) {
+		processedCount++;
+		console.log(
+			`[DEBUG] Processing issue #${issue.number} (${processedCount}/${allIssues.length}): ${issue.title}`
+		);
+
+		console.log(`[DEBUG] Fetching comments for issue #${issue.number}...`);
+		const comments = await githubRequest(
+			`/repos/${owner}/${repo}/issues/${issue.number}/comments`,
+			token
+		);
+		console.log(
+			`[DEBUG] Issue #${issue.number} has ${comments.length} comments`
+		);
+
+		// Look for existing duplicate detection comments (from the dedupe bot)
+		const dupeDetectionComments = comments.filter(
+			(comment) =>
+				comment.body.includes('Found') &&
+				comment.body.includes('possible duplicate') &&
+				comment.user.type === 'Bot'
+		);
+
+		console.log(
+			`[DEBUG] Issue #${issue.number} has ${dupeDetectionComments.length} duplicate detection comments`
+		);
+
+		// Skip if there's already a duplicate detection comment
+		if (dupeDetectionComments.length > 0) {
+			console.log(
+				`[DEBUG] Issue #${issue.number} already has duplicate detection comment, skipping`
+			);
+			continue;
+		}
+
+		candidateCount++;
+		const issueUrl = `https://github.com/${owner}/${repo}/issues/${issue.number}`;
+
+		try {
+			console.log(
+				`[INFO] ${dryRun ? '[DRY RUN] ' : ''}Triggering dedupe workflow for issue #${issue.number}: ${issueUrl}`
+			);
+			await triggerDedupeWorkflow(owner, repo, issue.number, token, dryRun);
+
+			if (!dryRun) {
+				console.log(
+					`[SUCCESS] Successfully triggered dedupe workflow for issue #${issue.number}`
+				);
+			}
+			triggeredCount++;
+		} catch (error) {
+			console.error(
+				`[ERROR] Failed to trigger workflow for issue #${issue.number}: ${error}`
+			);
+		}
+
+		// Add a delay between workflow triggers to avoid overwhelming the system
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+	}
+
+	console.log(
+		`[DEBUG] Script completed. Processed ${processedCount} issues, found ${candidateCount} candidates without duplicate comments, ${dryRun ? 'would trigger' : 'triggered'} ${triggeredCount} workflows`
+	);
+}
+
+backfillDuplicateComments().catch(console.error);

.github/scripts/check-pre-release-mode.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Get context from command line argument or environment
+const context = process.argv[2] || process.env.GITHUB_WORKFLOW || 'manual';
+
+function findRootDir(startDir) {
+	let currentDir = resolve(startDir);
+	while (currentDir !== '/') {
+		if (existsSync(join(currentDir, 'package.json'))) {
+			try {
+				const pkg = JSON.parse(
+					readFileSync(join(currentDir, 'package.json'), 'utf8')
+				);
+				if (pkg.name === 'task-master-ai' || pkg.repository) {
+					return currentDir;
+				}
+			} catch {}
+		}
+		currentDir = dirname(currentDir);
+	}
+	throw new Error('Could not find root directory');
+}
+
+function checkPreReleaseMode() {
+	console.log('🔍 Checking if branch is in pre-release mode...');
+
+	const rootDir = findRootDir(__dirname);
+	const preJsonPath = join(rootDir, '.changeset', 'pre.json');
+
+	// Check if pre.json exists
+	if (!existsSync(preJsonPath)) {
+		console.log('✅ Not in active pre-release mode - safe to proceed');
+		process.exit(0);
+	}
+
+	try {
+		// Read and parse pre.json
+		const preJsonContent = readFileSync(preJsonPath, 'utf8');
+		const preJson = JSON.parse(preJsonContent);
+
+		// Check if we're in active pre-release mode
+		if (preJson.mode === 'pre') {
+			console.error('❌ ERROR: This branch is in active pre-release mode!');
+			console.error('');
+
+			// Provide context-specific error messages
+			if (context === 'Release Check' || context === 'pull_request') {
+				console.error(
+					'Pre-release mode must be exited before merging to main.'
+				);
+				console.error('');
+				console.error(
+					'To fix this, run the following commands in your branch:'
+				);
+				console.error('  npx changeset pre exit');
+				console.error('  git add -u');
+				console.error('  git commit -m "chore: exit pre-release mode"');
+				console.error('  git push');
+				console.error('');
+				console.error('Then update this pull request.');
+			} else if (context === 'Release' || context === 'main') {
+				console.error(
+					'Pre-release mode should only be used on feature branches, not main.'
+				);
+				console.error('');
+				console.error('To fix this, run the following commands locally:');
+				console.error('  npx changeset pre exit');
+				console.error('  git add -u');
+				console.error('  git commit -m "chore: exit pre-release mode"');
+				console.error('  git push origin main');
+				console.error('');
+				console.error('Then re-run this workflow.');
+			} else {
+				console.error('Pre-release mode must be exited before proceeding.');
+				console.error('');
+				console.error('To fix this, run the following commands:');
+				console.error('  npx changeset pre exit');
+				console.error('  git add -u');
+				console.error('  git commit -m "chore: exit pre-release mode"');
+				console.error('  git push');
+			}
+
+			process.exit(1);
+		}
+
+		console.log('✅ Not in active pre-release mode - safe to proceed');
+		process.exit(0);
+	} catch (error) {
+		console.error(`❌ ERROR: Unable to parse .changeset/pre.json – aborting.`);
+		console.error(`Error details: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+// Run the check
+checkPreReleaseMode();

.github/scripts/parse-metrics.mjs

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

.github/scripts/release.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { existsSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findRootDir, runCommand } from './utils.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const rootDir = findRootDir(__dirname);
+
+console.log('🚀 Starting release process...');
+
+// Double-check we're not in pre-release mode (safety net)
+const preJsonPath = join(rootDir, '.changeset', 'pre.json');
+if (existsSync(preJsonPath)) {
+	console.log('⚠️  Warning: pre.json still exists. Removing it...');
+	unlinkSync(preJsonPath);
+}
+
+// Check if the extension version has changed and tag it
+// This prevents changeset from trying to publish the private package
+runCommand('node', [join(__dirname, 'tag-extension.mjs')]);
+
+// Run changeset publish for npm packages
+runCommand('npx', ['changeset', 'publish']);
+
+console.log('✅ Release process completed!');
+
+// The extension tag (if created) will trigger the extension-release workflow

.github/scripts/tag-extension.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findRootDir, createAndPushTag } from './utils.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const rootDir = findRootDir(__dirname);
+
+// Read the extension's package.json
+const extensionDir = join(rootDir, 'apps', 'extension');
+const pkgPath = join(extensionDir, 'package.json');
+
+let pkg;
+try {
+	const pkgContent = readFileSync(pkgPath, 'utf8');
+	pkg = JSON.parse(pkgContent);
+} catch (error) {
+	console.error('Failed to read package.json:', error.message);
+	process.exit(1);
+}
+
+// Ensure we have required fields
+assert(pkg.name, 'package.json must have a name field');
+assert(pkg.version, 'package.json must have a version field');
+
+const tag = `${pkg.name}@${pkg.version}`;
+
+// Create and push the tag if it doesn't exist
+createAndPushTag(tag);

.github/scripts/utils.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+
+// Find the root directory by looking for package.json with task-master-ai
+export function findRootDir(startDir) {
+	let currentDir = resolve(startDir);
+	while (currentDir !== '/') {
+		const pkgPath = join(currentDir, 'package.json');
+		try {
+			const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+			if (pkg.name === 'task-master-ai' || pkg.repository) {
+				return currentDir;
+			}
+		} catch {}
+		currentDir = dirname(currentDir);
+	}
+	throw new Error('Could not find root directory');
+}
+
+// Run a command with proper error handling
+export function runCommand(command, args = [], options = {}) {
+	console.log(`Running: ${command} ${args.join(' ')}`);
+	const result = spawnSync(command, args, {
+		encoding: 'utf8',
+		stdio: 'inherit',
+		...options
+	});
+
+	if (result.status !== 0) {
+		console.error(`Command failed with exit code ${result.status}`);
+		process.exit(result.status);
+	}
+
+	return result;
+}
+
+// Get package version from a package.json file
+export function getPackageVersion(packagePath) {
+	try {
+		const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+		return pkg.version;
+	} catch (error) {
+		console.error(
+			`Failed to read package version from ${packagePath}:`,
+			error.message
+		);
+		process.exit(1);
+	}
+}
+
+// Check if a git tag exists on remote
+export function tagExistsOnRemote(tag, remote = 'origin') {
+	const result = spawnSync('git', ['ls-remote', remote, tag], {
+		encoding: 'utf8'
+	});
+
+	return result.status === 0 && result.stdout.trim() !== '';
+}
+
+// Create and push a git tag if it doesn't exist
+export function createAndPushTag(tag, remote = 'origin') {
+	// Check if tag already exists
+	if (tagExistsOnRemote(tag, remote)) {
+		console.log(`Tag ${tag} already exists on remote, skipping`);
+		return false;
+	}
+
+	console.log(`Creating new tag: ${tag}`);
+
+	// Create the tag locally
+	const tagResult = spawnSync('git', ['tag', tag]);
+	if (tagResult.status !== 0) {
+		console.error('Failed to create tag:', tagResult.error || tagResult.stderr);
+		process.exit(1);
+	}
+
+	// Push the tag to remote
+	const pushResult = spawnSync('git', ['push', remote, tag]);
+	if (pushResult.status !== 0) {
+		console.error('Failed to push tag:', pushResult.error || pushResult.stderr);
+		process.exit(1);
+	}
+
+	console.log(`✅ Successfully created and pushed tag: ${tag}`);
+	return true;
+}

.github/workflows/auto-close-duplicates.yml

@@ -0,0 +1,31 @@
+name: Auto-close duplicate issues
+# description: Auto-closes issues that are duplicates of existing issues
+
+on:
+  schedule:
+    - cron: "0 9 * * *"  # Runs daily at 9 AM UTC
+  workflow_dispatch:
+
+jobs:
+  auto-close-duplicates:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      issues: write  # Need write permission to close issues and add comments
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Auto-close duplicate issues
+        run: node .github/scripts/auto-close-duplicates.mjs
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
+          GITHUB_REPOSITORY_NAME: ${{ github.event.repository.name }}

.github/workflows/backfill-duplicate-comments.yml

@@ -0,0 +1,46 @@
+name: Backfill Duplicate Comments
+# description: Triggers duplicate detection for old issues that don't have duplicate comments
+
+on:
+  workflow_dispatch:
+    inputs:
+      days_back:
+        description: "How many days back to look for old issues"
+        required: false
+        default: "90"
+        type: string
+      dry_run:
+        description: "Dry run mode (true to only log what would be done)"
+        required: false
+        default: "true"
+        type: choice
+        options:
+          - "true"
+          - "false"
+
+jobs:
+  backfill-duplicate-comments:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      issues: read
+      actions: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Backfill duplicate comments
+        run: node .github/scripts/backfill-duplicate-comments.mjs
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
+          GITHUB_REPOSITORY_NAME: ${{ github.event.repository.name }}
+          DAYS_BACK: ${{ inputs.days_back }}
+          DRY_RUN: ${{ inputs.dry_run }}

.github/workflows/ci.yml

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

.github/workflows/claude-dedupe-issues.yml

@@ -0,0 +1,81 @@
+name: Claude Issue Dedupe
+# description: Automatically dedupe GitHub issues using Claude Code
+
+on:
+  issues:
+    types: [opened]
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: "Issue number to process for duplicate detection"
+        required: true
+        type: string
+
+jobs:
+  claude-dedupe-issues:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      issues: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Run Claude Code slash command
+        uses: anthropics/claude-code-base-action@beta
+        with:
+          prompt: "/dedupe ${{ github.repository }}/issues/${{ github.event.issue.number || inputs.issue_number }}"
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          claude_env: |
+            GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Log duplicate comment event to Statsig
+        if: always()
+        env:
+          STATSIG_API_KEY: ${{ secrets.STATSIG_API_KEY }}
+        run: |
+          ISSUE_NUMBER=${{ github.event.issue.number || inputs.issue_number }}
+          REPO=${{ github.repository }}
+
+          if [ -z "$STATSIG_API_KEY" ]; then
+            echo "STATSIG_API_KEY not found, skipping Statsig logging"
+            exit 0
+          fi
+
+          # Prepare the event payload
+          EVENT_PAYLOAD=$(jq -n \
+            --arg issue_number "$ISSUE_NUMBER" \
+            --arg repo "$REPO" \
+            --arg triggered_by "${{ github.event_name }}" \
+            '{
+              events: [{
+                eventName: "github_duplicate_comment_added",
+                value: 1,
+                metadata: {
+                  repository: $repo,
+                  issue_number: ($issue_number | tonumber),
+                  triggered_by: $triggered_by,
+                  workflow_run_id: "${{ github.run_id }}"
+                },
+                time: (now | floor | tostring)
+              }]
+            }')
+
+          # Send to Statsig API
+          echo "Logging duplicate comment event to Statsig for issue #${ISSUE_NUMBER}"
+
+          RESPONSE=$(curl -s -w "\n%{http_code}" -X POST https://events.statsigapi.net/v1/log_event \
+            -H "Content-Type: application/json" \
+            -H "STATSIG-API-KEY: ${STATSIG_API_KEY}" \
+            -d "$EVENT_PAYLOAD")
+
+          HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+          BODY=$(echo "$RESPONSE" | head -n-1)
+
+          if [ "$HTTP_CODE" -eq 200 ] || [ "$HTTP_CODE" -eq 202 ]; then
+            echo "Successfully logged duplicate comment event for issue #${ISSUE_NUMBER}"
+          else
+            echo "Failed to log duplicate comment event for issue #${ISSUE_NUMBER}. HTTP ${HTTP_CODE}: ${BODY}"
+          fi

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

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

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

@@ -0,0 +1,145 @@
+name: Claude Documentation Updater
+
+on:
+  workflow_dispatch:
+    inputs:
+      commit_sha:
+        description: 'The commit SHA that triggered this update'
+        required: true
+        type: string
+      commit_message:
+        description: 'The commit message'
+        required: true
+        type: string
+      changed_files:
+        description: 'List of changed files'
+        required: true
+        type: string
+      commit_diff:
+        description: 'Diff summary of changes'
+        required: true
+        type: string
+
+jobs:
+  update-docs:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: next
+          fetch-depth: 0 # Need full history to checkout specific commit
+
+      - name: Create docs update branch
+        id: create-branch
+        run: |
+          BRANCH_NAME="docs/auto-update-$(date +%Y%m%d-%H%M%S)"
+          git checkout -b $BRANCH_NAME
+          echo "branch_name=$BRANCH_NAME" >> $GITHUB_OUTPUT
+
+      - name: Run Claude Code to Update Documentation
+        uses: anthropics/claude-code-action@beta
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          timeout_minutes: "30"
+          mode: "agent"
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          experimental_allowed_domains: |
+            .anthropic.com
+            .github.com
+            api.github.com
+            .githubusercontent.com
+            registry.npmjs.org
+            .task-master.dev
+          base_branch: "next"
+          direct_prompt: |
+            You are a documentation specialist. Analyze the recent changes pushed to the 'next' branch and update the documentation accordingly.
+
+            Recent changes:
+            - Commit: ${{ inputs.commit_message }}
+            - Changed files:
+            ${{ inputs.changed_files }}
+
+            - Changes summary:
+            ${{ inputs.commit_diff }}
+
+            Your task:
+            1. Analyze the changes to understand what functionality was added, modified, or removed
+            2. Check if these changes require documentation updates in apps/docs/
+            3. If documentation updates are needed:
+               - Update relevant documentation files in apps/docs/
+               - Ensure examples are updated if APIs changed
+               - Update any configuration documentation if config options changed
+               - Add new documentation pages if new features were added
+               - Update the changelog or release notes if applicable
+            4. If no documentation updates are needed, skip creating changes
+
+            Guidelines:
+            - Focus only on user-facing changes that need documentation
+            - Keep documentation clear, concise, and helpful
+            - Include code examples where appropriate
+            - Maintain consistent documentation style with existing docs
+            - Don't document internal implementation details unless they affect users
+            - Update navigation/menu files if new pages are added
+
+            Only make changes if the documentation truly needs updating based on the code changes.
+
+      - name: Check if changes were made
+        id: check-changes
+        run: |
+          if git diff --quiet; then
+            echo "has_changes=false" >> $GITHUB_OUTPUT
+          else
+            echo "has_changes=true" >> $GITHUB_OUTPUT
+            git add -A
+            git config --local user.email "github-actions[bot]@users.noreply.github.com"
+            git config --local user.name "github-actions[bot]"
+            git commit -m "docs: auto-update documentation based on changes in next branch
+
+            This PR was automatically generated to update documentation based on recent changes.
+            
+            Original commit: ${{ inputs.commit_message }}
+            
+            Co-authored-by: Claude <claude-assistant@anthropic.com>"
+          fi
+
+      - name: Push changes and create PR
+        if: steps.check-changes.outputs.has_changes == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git push origin ${{ steps.create-branch.outputs.branch_name }}
+
+          # Create PR using GitHub CLI
+          gh pr create \
+            --title "docs: update documentation for recent changes" \
+            --body "## 📚 Documentation Update
+
+            This PR automatically updates documentation based on recent changes merged to the \`next\` branch.
+
+            ### Original Changes
+            **Commit:** ${{ inputs.commit_sha }}
+            **Message:** ${{ inputs.commit_message }}
+            
+            ### Changed Files in Original Commit
+            \`\`\`
+            ${{ inputs.changed_files }}
+            \`\`\`
+
+            ### Documentation Updates
+            This PR includes documentation updates to reflect the changes above. Please review to ensure:
+            - [ ] Documentation accurately reflects the changes
+            - [ ] Examples are correct and working
+            - [ ] No important details are missing
+            - [ ] Style is consistent with existing documentation
+
+            ---
+            *This PR was automatically generated by Claude Code GitHub Action*" \
+            --base next \
+            --head ${{ steps.create-branch.outputs.branch_name }} \
+            --label "documentation" \
+            --label "automated"

.github/workflows/claude-issue-triage.yml

@@ -0,0 +1,107 @@
+name: Claude Issue Triage
+# description: Automatically triage GitHub issues using Claude Code
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  triage-issue:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      issues: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Create triage prompt
+        run: |
+          mkdir -p /tmp/claude-prompts
+          cat > /tmp/claude-prompts/triage-prompt.txt << 'EOF'
+          You're an issue triage assistant for GitHub issues. Your task is to analyze the issue and select appropriate labels from the provided list.
+
+          IMPORTANT: Don't post any comments or messages to the issue. Your only action should be to apply labels.
+
+          Issue Information:
+          - REPO: ${{ github.repository }}
+          - ISSUE_NUMBER: ${{ github.event.issue.number }}
+
+          TASK OVERVIEW:
+
+          1. First, fetch the list of labels available in this repository by running: `gh label list`. Run exactly this command with nothing else.
+
+          2. Next, use the GitHub tools to get context about the issue:
+             - You have access to these tools:
+               - mcp__github__get_issue: Use this to retrieve the current issue's details including title, description, and existing labels
+               - mcp__github__get_issue_comments: Use this to read any discussion or additional context provided in the comments
+               - mcp__github__update_issue: Use this to apply labels to the issue (do not use this for commenting)
+               - mcp__github__search_issues: Use this to find similar issues that might provide context for proper categorization and to identify potential duplicate issues
+               - mcp__github__list_issues: Use this to understand patterns in how other issues are labeled
+             - Start by using mcp__github__get_issue to get the issue details
+
+          3. Analyze the issue content, considering:
+             - The issue title and description
+             - The type of issue (bug report, feature request, question, etc.)
+             - Technical areas mentioned
+             - Severity or priority indicators
+             - User impact
+             - Components affected
+
+          4. Select appropriate labels from the available labels list provided above:
+             - Choose labels that accurately reflect the issue's nature
+             - Be specific but comprehensive
+             - Select priority labels if you can determine urgency (high-priority, med-priority, or low-priority)
+             - Consider platform labels (android, ios) if applicable
+             - If you find similar issues using mcp__github__search_issues, consider using a "duplicate" label if appropriate. Only do so if the issue is a duplicate of another OPEN issue.
+
+          5. Apply the selected labels:
+             - Use mcp__github__update_issue to apply your selected labels
+             - DO NOT post any comments explaining your decision
+             - DO NOT communicate directly with users
+             - If no labels are clearly applicable, do not apply any labels
+
+          IMPORTANT GUIDELINES:
+          - Be thorough in your analysis
+          - Only select labels from the provided list above
+          - DO NOT post any comments to the issue
+          - Your ONLY action should be to apply labels using mcp__github__update_issue
+          - It's okay to not add any labels if none are clearly applicable
+          EOF
+
+      - name: Setup GitHub MCP Server
+        run: |
+          mkdir -p /tmp/mcp-config
+          cat > /tmp/mcp-config/mcp-servers.json << 'EOF'
+          {
+            "mcpServers": {
+              "github": {
+                "command": "docker",
+                "args": [
+                  "run",
+                  "-i",
+                  "--rm",
+                  "-e",
+                  "GITHUB_PERSONAL_ACCESS_TOKEN",
+                  "ghcr.io/github/github-mcp-server:sha-7aced2b"
+                ],
+                "env": {
+                  "GITHUB_PERSONAL_ACCESS_TOKEN": "${{ secrets.GITHUB_TOKEN }}"
+                }
+              }
+            }
+          }
+          EOF
+
+      - name: Run Claude Code for Issue Triage
+        uses: anthropics/claude-code-base-action@beta
+        with:
+          prompt_file: /tmp/claude-prompts/triage-prompt.txt
+          allowed_tools: "Bash(gh label list),mcp__github__get_issue,mcp__github__get_issue_comments,mcp__github__update_issue,mcp__github__search_issues,mcp__github__list_issues"
+          timeout_minutes: "5"
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          mcp_config: /tmp/mcp-config/mcp-servers.json
+          claude_env: |
+            GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/claude.yml

@@ -0,0 +1,36 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@beta
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

.github/workflows/extension-ci.yml

@@ -0,0 +1,140 @@
+name: Extension CI
+
+on:
+  push:
+    branches:
+      - main
+      - next
+    paths:
+      - 'apps/extension/**'
+      - '.github/workflows/extension-ci.yml'
+  pull_request:
+    branches:
+      - main
+      - next
+    paths:
+      - 'apps/extension/**'
+      - '.github/workflows/extension-ci.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Cache node_modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install Monorepo Dependencies
+        run: npm ci
+        timeout-minutes: 5
+
+  typecheck:
+    needs: setup
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+
+      - name: Restore node_modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install if cache miss
+        run: npm ci
+        timeout-minutes: 3
+
+      - name: Type Check Extension
+        working-directory: apps/extension
+        run: npm run check-types
+        env:
+          FORCE_COLOR: 1
+
+  build:
+    needs: setup
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+
+      - name: Restore node_modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install if cache miss
+        run: npm ci
+        timeout-minutes: 3
+
+      - name: Build Extension
+        working-directory: apps/extension
+        run: npm run build
+        env:
+          FORCE_COLOR: 1
+
+      - name: Package Extension
+        working-directory: apps/extension
+        run: npm run package
+        env:
+          FORCE_COLOR: 1
+
+      - name: Verify Package Contents
+        working-directory: apps/extension
+        run: |
+          echo "Checking vsix-build contents..."
+          ls -la vsix-build/
+          echo "Checking dist contents..."
+          ls -la vsix-build/dist/
+          echo "Checking package.json exists..."
+          test -f vsix-build/package.json
+
+      - name: Create VSIX Package (Test)
+        working-directory: apps/extension/vsix-build
+        run: npx vsce package --no-dependencies
+        env:
+          FORCE_COLOR: 1
+
+      - name: Upload Extension Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: extension-package
+          path: |
+            apps/extension/vsix-build/*.vsix
+            apps/extension/dist/
+          retention-days: 30
+

.github/workflows/extension-release.yml

@@ -0,0 +1,110 @@
+name: Extension Release
+
+on:
+  push:
+    tags:
+      - "extension@*"
+
+permissions:
+  contents: write
+
+concurrency: extension-release-${{ github.ref }}
+
+jobs:
+  publish-extension:
+    runs-on: ubuntu-latest
+    environment: extension-release
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Cache node_modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install Monorepo Dependencies
+        run: npm ci
+        timeout-minutes: 5
+
+      - name: Type Check Extension
+        working-directory: apps/extension
+        run: npm run check-types
+        env:
+          FORCE_COLOR: 1
+
+      - name: Build Extension
+        working-directory: apps/extension
+        run: npm run build
+        env:
+          FORCE_COLOR: 1
+
+      - name: Package Extension
+        working-directory: apps/extension
+        run: npm run package
+        env:
+          FORCE_COLOR: 1
+
+      - name: Create VSIX Package
+        working-directory: apps/extension/vsix-build
+        run: npx vsce package --no-dependencies
+        env:
+          FORCE_COLOR: 1
+
+      - name: Get VSIX filename
+        id: vsix-info
+        working-directory: apps/extension/vsix-build
+        run: |
+          VSIX_FILE=$(find . -maxdepth 1 -name "*.vsix" -type f | head -n1 | xargs basename)
+          if [ -z "$VSIX_FILE" ]; then
+            echo "Error: No VSIX file found"
+            exit 1
+          fi
+          echo "vsix-filename=$VSIX_FILE" >> "$GITHUB_OUTPUT"
+          echo "Found VSIX: $VSIX_FILE"
+
+      - name: Publish to VS Code Marketplace
+        working-directory: apps/extension/vsix-build
+        run: npx vsce publish --packagePath "${{ steps.vsix-info.outputs.vsix-filename }}"
+        env:
+          VSCE_PAT: ${{ secrets.VSCE_PAT }}
+          FORCE_COLOR: 1
+
+      - name: Install Open VSX CLI
+        run: npm install -g ovsx
+
+      - name: Publish to Open VSX Registry
+        working-directory: apps/extension/vsix-build
+        run: ovsx publish "${{ steps.vsix-info.outputs.vsix-filename }}"
+        env:
+          OVSX_PAT: ${{ secrets.OVSX_PAT }}
+          FORCE_COLOR: 1
+
+      - name: Upload Build Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: extension-release-${{ github.ref_name }}
+          path: |
+            apps/extension/vsix-build/*.vsix
+            apps/extension/dist/
+          retention-days: 90
+
+  notify-success:
+    needs: publish-extension
+    if: success()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Success Notification
+        run: |
+          echo "🎉 Extension ${{ github.ref_name }} successfully published!"
+          echo "📦 Available on VS Code Marketplace"
+          echo "🌍 Available on Open VSX Registry"
+          echo "🏷️ GitHub release created: ${{ github.ref_name }}"

.github/workflows/log-issue-events.yml

@@ -0,0 +1,176 @@
+name: Log GitHub Issue Events
+
+on:
+  issues:
+    types: [opened, closed]
+
+jobs:
+  log-issue-created:
+    if: github.event.action == 'opened'
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      contents: read
+      issues: read
+
+    steps:
+      - name: Log issue creation to Statsig
+        env:
+          STATSIG_API_KEY: ${{ secrets.STATSIG_API_KEY }}
+        run: |
+          ISSUE_NUMBER=${{ github.event.issue.number }}
+          REPO=${{ github.repository }}
+          ISSUE_TITLE=$(echo '${{ github.event.issue.title }}' | sed "s/'/'\\\\''/g")
+          AUTHOR="${{ github.event.issue.user.login }}"
+          CREATED_AT="${{ github.event.issue.created_at }}"
+
+          if [ -z "$STATSIG_API_KEY" ]; then
+            echo "STATSIG_API_KEY not found, skipping Statsig logging"
+            exit 0
+          fi
+
+          # Prepare the event payload
+          EVENT_PAYLOAD=$(jq -n \
+            --arg issue_number "$ISSUE_NUMBER" \
+            --arg repo "$REPO" \
+            --arg title "$ISSUE_TITLE" \
+            --arg author "$AUTHOR" \
+            --arg created_at "$CREATED_AT" \
+            '{
+              events: [{
+                eventName: "github_issue_created",
+                value: 1,
+                metadata: {
+                  repository: $repo,
+                  issue_number: ($issue_number | tonumber),
+                  issue_title: $title,
+                  issue_author: $author,
+                  created_at: $created_at
+                },
+                time: (now | floor | tostring)
+              }]
+            }')
+
+          # Send to Statsig API
+          echo "Logging issue creation to Statsig for issue #${ISSUE_NUMBER}"
+
+          RESPONSE=$(curl -s -w "\n%{http_code}" -X POST https://events.statsigapi.net/v1/log_event \
+            -H "Content-Type: application/json" \
+            -H "STATSIG-API-KEY: ${STATSIG_API_KEY}" \
+            -d "$EVENT_PAYLOAD")
+
+          HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+          BODY=$(echo "$RESPONSE" | head -n-1)
+
+          if [ "$HTTP_CODE" -eq 200 ] || [ "$HTTP_CODE" -eq 202 ]; then
+            echo "Successfully logged issue creation for issue #${ISSUE_NUMBER}"
+          else
+            echo "Failed to log issue creation for issue #${ISSUE_NUMBER}. HTTP ${HTTP_CODE}: ${BODY}"
+          fi
+
+  log-issue-closed:
+    if: github.event.action == 'closed'
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      contents: read
+      issues: read
+
+    steps:
+      - name: Log issue closure to Statsig
+        env:
+          STATSIG_API_KEY: ${{ secrets.STATSIG_API_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          ISSUE_NUMBER=${{ github.event.issue.number }}
+          REPO=${{ github.repository }}
+          ISSUE_TITLE=$(echo '${{ github.event.issue.title }}' | sed "s/'/'\\\\''/g")
+          CLOSED_BY="${{ github.event.issue.closed_by.login }}"
+          CLOSED_AT="${{ github.event.issue.closed_at }}"
+          STATE_REASON="${{ github.event.issue.state_reason }}"
+
+          if [ -z "$STATSIG_API_KEY" ]; then
+            echo "STATSIG_API_KEY not found, skipping Statsig logging"
+            exit 0
+          fi
+
+          # Get additional issue data via GitHub API
+          echo "Fetching additional issue data for #${ISSUE_NUMBER}"
+          ISSUE_DATA=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${REPO}/issues/${ISSUE_NUMBER}")
+
+          COMMENTS_COUNT=$(echo "$ISSUE_DATA" | jq -r '.comments')
+
+          # Get reactions data
+          REACTIONS_DATA=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${REPO}/issues/${ISSUE_NUMBER}/reactions")
+
+          REACTIONS_COUNT=$(echo "$REACTIONS_DATA" | jq '. | length')
+
+          # Check if issue was closed automatically (by checking if closed_by is a bot)
+          CLOSED_AUTOMATICALLY="false"
+          if [[ "$CLOSED_BY" == *"[bot]"* ]]; then
+            CLOSED_AUTOMATICALLY="true"
+          fi
+
+          # Check if closed as duplicate by state_reason
+          CLOSED_AS_DUPLICATE="false"
+          if [ "$STATE_REASON" = "duplicate" ]; then
+            CLOSED_AS_DUPLICATE="true"
+          fi
+
+          # Prepare the event payload
+          EVENT_PAYLOAD=$(jq -n \
+            --arg issue_number "$ISSUE_NUMBER" \
+            --arg repo "$REPO" \
+            --arg title "$ISSUE_TITLE" \
+            --arg closed_by "$CLOSED_BY" \
+            --arg closed_at "$CLOSED_AT" \
+            --arg state_reason "$STATE_REASON" \
+            --arg comments_count "$COMMENTS_COUNT" \
+            --arg reactions_count "$REACTIONS_COUNT" \
+            --arg closed_automatically "$CLOSED_AUTOMATICALLY" \
+            --arg closed_as_duplicate "$CLOSED_AS_DUPLICATE" \
+            '{
+              events: [{
+                eventName: "github_issue_closed",
+                value: 1,
+                metadata: {
+                  repository: $repo,
+                  issue_number: ($issue_number | tonumber),
+                  issue_title: $title,
+                  closed_by: $closed_by,
+                  closed_at: $closed_at,
+                  state_reason: $state_reason,
+                  comments_count: ($comments_count | tonumber),
+                  reactions_count: ($reactions_count | tonumber),
+                  closed_automatically: ($closed_automatically | test("true")),
+                  closed_as_duplicate: ($closed_as_duplicate | test("true"))
+                },
+                time: (now | floor | tostring)
+              }]
+            }')
+
+          # Send to Statsig API
+          echo "Logging issue closure to Statsig for issue #${ISSUE_NUMBER}"
+
+          RESPONSE=$(curl -s -w "\n%{http_code}" -X POST https://events.statsigapi.net/v1/log_event \
+            -H "Content-Type: application/json" \
+            -H "STATSIG-API-KEY: ${STATSIG_API_KEY}" \
+            -d "$EVENT_PAYLOAD")
+
+          HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+          BODY=$(echo "$RESPONSE" | head -n-1)
+
+          if [ "$HTTP_CODE" -eq 200 ] || [ "$HTTP_CODE" -eq 202 ]; then
+            echo "Successfully logged issue closure for issue #${ISSUE_NUMBER}"
+            echo "Closed by: $CLOSED_BY"
+            echo "Comments: $COMMENTS_COUNT"
+            echo "Reactions: $REACTIONS_COUNT"
+            echo "Closed automatically: $CLOSED_AUTOMATICALLY"
+            echo "Closed as duplicate: $CLOSED_AS_DUPLICATE"
+          else
+            echo "Failed to log issue closure for issue #${ISSUE_NUMBER}. HTTP ${HTTP_CODE}: ${BODY}"
+          fi

.github/workflows/pre-release.yml

@@ -3,11 +3,13 @@ name: Pre-Release (RC)
 on:
   workflow_dispatch: # Allows manual triggering from GitHub UI/API
 
-concurrency: pre-release-${{ github.ref }}
-
+concurrency: pre-release-${{ github.ref_name }}
 jobs:
   rc:
     runs-on: ubuntu-latest
+    # Only allow pre-releases on non-main branches
+    if: github.ref != 'refs/heads/main'
+    environment: extension-release
     steps:
       - uses: actions/checkout@v4
         with:
@@ -16,7 +18,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: 'npm'
+          cache: "npm"
 
       - name: Cache node_modules
         uses: actions/cache@v4
@@ -32,10 +34,30 @@ jobs:
         run: npm ci
         timeout-minutes: 2
 
-      - name: Enter RC mode
+      - name: Enter RC mode (if not already in RC mode)
         run: |
-          npx changeset pre exit || true
+          # Check if we're in pre-release mode with the "rc" tag
+          if [ -f .changeset/pre.json ]; then
+            MODE=$(jq -r '.mode' .changeset/pre.json 2>/dev/null || echo '')
+            TAG=$(jq -r '.tag' .changeset/pre.json 2>/dev/null || echo '')
+            
+            if [ "$MODE" = "exit" ]; then
+              echo "Pre-release mode is in 'exit' state, re-entering RC mode..."
               npx changeset pre enter rc
+            elif [ "$MODE" = "pre" ] && [ "$TAG" != "rc" ]; then
+              echo "In pre-release mode but with wrong tag ($TAG), switching to RC..."
+              npx changeset pre exit
+              npx changeset pre enter rc
+            elif [ "$MODE" = "pre" ] && [ "$TAG" = "rc" ]; then
+              echo "Already in RC pre-release mode"
+            else
+              echo "Unknown mode state: $MODE, entering RC mode..."
+              npx changeset pre enter rc
+            fi
+          else
+            echo "No pre.json found, entering RC mode..."
+            npx changeset pre enter rc
+          fi
 
       - name: Version RC packages
         run: npx changeset version
@@ -43,20 +65,31 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
+      - name: Run format
+        run: npm run format
+        env:
+          FORCE_COLOR: 1
+
+      - name: Build packages
+        run: npm run turbo:build
+        env:
+          NODE_ENV: production
+          FORCE_COLOR: 1
+          TM_PUBLIC_BASE_DOMAIN: ${{ secrets.TM_PUBLIC_BASE_DOMAIN }}
+          TM_PUBLIC_SUPABASE_URL: ${{ secrets.TM_PUBLIC_SUPABASE_URL }}
+          TM_PUBLIC_SUPABASE_ANON_KEY: ${{ secrets.TM_PUBLIC_SUPABASE_ANON_KEY }}
+
       - name: Create Release Candidate Pull Request or Publish Release Candidate to npm
         uses: changesets/action@v1
         with:
-          publish: npm run release
+          publish: npx changeset publish
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-      - name: Exit RC mode
-        run: npx changeset pre exit
-
       - name: Commit & Push changes
         uses: actions-js/push@master
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           branch: ${{ github.ref }}
-          message: 'chore: rc version bump'
+          message: "chore: rc version bump"

.github/workflows/release-check.yml

@@ -0,0 +1,21 @@
+name: Release Check
+
+on:
+  pull_request:
+    branches:
+      - main
+
+concurrency:
+  group: release-check-${{ github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  check-release-mode:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check release mode
+        run: node ./.github/scripts/check-pre-release-mode.mjs "pull_request"

.github/workflows/release.yml

@@ -6,6 +6,11 @@ on:
 
 concurrency: ${{ github.workflow }}-${{ github.ref }}
 
+permissions:
+  contents: write
+  pull-requests: write
+  id-token: write
+
 jobs:
   release:
     runs-on: ubuntu-latest
@@ -17,7 +22,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: 'npm'
+          cache: "npm"
 
       - name: Cache node_modules
         uses: actions/cache@v4
@@ -33,13 +38,22 @@ jobs:
         run: npm ci
         timeout-minutes: 2
 
-      - name: Exit pre-release mode (safety check)
-        run: npx changeset pre exit || true
+      - name: Check pre-release mode
+        run: node ./.github/scripts/check-pre-release-mode.mjs "main"
+
+      - name: Build packages
+        run: npm run turbo:build
+        env:
+          NODE_ENV: production
+          FORCE_COLOR: 1
+          TM_PUBLIC_BASE_DOMAIN: ${{ secrets.TM_PUBLIC_BASE_DOMAIN }}
+          TM_PUBLIC_SUPABASE_URL: ${{ secrets.TM_PUBLIC_SUPABASE_URL }}
+          TM_PUBLIC_SUPABASE_ANON_KEY: ${{ secrets.TM_PUBLIC_SUPABASE_ANON_KEY }}
 
       - name: Create Release Pull Request or Publish to npm
         uses: changesets/action@v1
         with:
-          publish: npm run release
+          publish: node ./.github/scripts/release.mjs
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

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

@@ -0,0 +1,108 @@
+name: Weekly Metrics to Discord
+# description: Sends weekly metrics summary to Discord channel
+
+on:
+  schedule:
+    - cron: "0 9 * * 1" # Every Monday at 9 AM
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  issues: read
+  pull-requests: read
+
+jobs:
+  weekly-metrics:
+    runs-on: ubuntu-latest
+    env:
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_METRICS_WEBHOOK }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Get dates for last 14 days
+        run: |
+          set -Eeuo pipefail
+          # Last 14 days
+          first_day=$(date -d "14 days ago" +%Y-%m-%d)
+          last_day=$(date +%Y-%m-%d)
+
+          echo "first_day=$first_day" >> $GITHUB_ENV
+          echo "last_day=$last_day" >> $GITHUB_ENV
+          echo "week_of=$(date -d '7 days ago' +'Week of %B %d, %Y')" >> $GITHUB_ENV
+          echo "date_range=Past 14 days ($first_day to $last_day)" >> $GITHUB_ENV
+
+      - name: Generate issue metrics
+        uses: github/issue-metrics@v3
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SEARCH_QUERY: "repo:${{ github.repository }} is:issue created:${{ env.first_day }}..${{ env.last_day }}"
+          HIDE_TIME_TO_ANSWER: true
+          HIDE_LABEL_METRICS: false
+          OUTPUT_FILE: issue_metrics.md
+
+      - name: Generate PR created metrics
+        uses: github/issue-metrics@v3
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SEARCH_QUERY: "repo:${{ github.repository }} is:pr created:${{ env.first_day }}..${{ env.last_day }}"
+          OUTPUT_FILE: pr_created_metrics.md
+
+      - name: Generate PR merged metrics
+        uses: github/issue-metrics@v3
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SEARCH_QUERY: "repo:${{ github.repository }} is:pr is:merged merged:${{ env.first_day }}..${{ env.last_day }}"
+          OUTPUT_FILE: pr_merged_metrics.md
+
+      - name: Debug generated metrics
+        run: |
+          set -Eeuo pipefail
+          echo "Listing markdown files in workspace:"
+          ls -la *.md || true
+          for f in issue_metrics.md pr_created_metrics.md pr_merged_metrics.md; do
+            if [ -f "$f" ]; then
+              echo "== $f (first 10 lines) =="
+              head -n 10 "$f"
+            else
+              echo "Missing $f"
+            fi
+          done
+
+      - name: Parse metrics
+        id: metrics
+        run: node .github/scripts/parse-metrics.mjs
+
+      - name: Send to Discord
+        uses: sarisia/actions-status-discord@v1
+        if: env.DISCORD_WEBHOOK != ''
+        with:
+          webhook: ${{ env.DISCORD_WEBHOOK }}
+          status: Success
+          title: "📊 Weekly Metrics Report"
+          description: |
+            **${{ env.week_of }}**
+            *${{ env.date_range }}*
+
+            **🎯 Issues**
+            • Created: ${{ steps.metrics.outputs.issues_created }}
+            • Closed: ${{ steps.metrics.outputs.issues_closed }}
+            • Avg Response Time: ${{ steps.metrics.outputs.issue_avg_first_response }}
+            • Avg Time to Close: ${{ steps.metrics.outputs.issue_avg_time_to_close }}
+
+            **🔀 Pull Requests**
+            • Created: ${{ steps.metrics.outputs.prs_created }}
+            • Merged: ${{ steps.metrics.outputs.prs_merged }}
+            • Avg Response Time: ${{ steps.metrics.outputs.pr_avg_first_response }}
+            • Avg Time to Merge: ${{ steps.metrics.outputs.pr_avg_merge_time }}
+
+            **📈 Visual Analytics**
+            https://repobeats.axiom.co/api/embed/b439f28f0ab5bd7a2da19505355693cd2c55bfd4.svg
+          color: 0x58AFFF
+          username: Task Master Metrics Bot
+          avatar_url: https://raw.githubusercontent.com/eyaltoledano/claude-task-master/main/images/logo.png

.gitignore

@@ -87,3 +87,16 @@ dev-debug.log
 *.njsproj
 *.sln
 *.sw?
+
+# VS Code extension test files
+.vscode-test/
+apps/extension/.vscode-test/
+
+# apps/extension
+apps/extension/vsix-build/
+
+# turbo
+.turbo
+
+# TaskMaster Workflow State (now stored in ~/.taskmaster/sessions/)
+# No longer needed in .gitignore as state is stored globally

.kiro/settings/mcp.json

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

.manypkg.json

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

.taskmaster/CLAUDE.md

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

.taskmaster/config.json

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

.taskmaster/docs/MIGRATION-ROADMAP.md

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

.taskmaster/docs/autonomous-tdd-git-workflow.md

@@ -0,0 +1,912 @@
+## 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>/.
+
+## Success Metrics (Phase 1)
+
+- **Adoption**: 80% of tasks in a pilot repo completed via `tm autopilot`
+- **Safety**: 0 commits to default branch; 100% of commits have green tests
+- **Efficiency**: Average time from task start to PR < 30min for simple subtasks
+- **Reliability**: < 5% of runs require manual intervention (timeout/conflicts)
+
+## 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.
+
+## Example Workflow Traces
+
+### Happy Path: Complete a 3-subtask feature
+
+```bash
+# Developer starts
+$ tm autopilot 42
+→ Checks preflight: ✓ clean tree, ✓ npm test detected
+→ Creates branch: analytics/task-42-user-metrics
+→ Subtask 42.1: "Add metrics schema"
+  RED: generates test_metrics_schema.test.js → 3 failures
+  GREEN: implements schema.js → all pass
+  COMMIT: "feat(metrics): add metrics schema (task 42.1)"
+→ Subtask 42.2: "Add collection endpoint"
+  RED: generates test_metrics_endpoint.test.js → 5 failures
+  GREEN: implements api/metrics.js → all pass
+  COMMIT: "feat(metrics): add collection endpoint (task 42.2)"
+→ Subtask 42.3: "Add dashboard widget"
+  RED: generates test_metrics_widget.test.js → 4 failures
+  GREEN: implements components/MetricsWidget.jsx → all pass
+  COMMIT: "feat(metrics): add dashboard widget (task 42.3)"
+→ Final: all 3 subtasks complete
+  ✓ Run full test suite → all pass
+  ✓ Coverage check → 85% (meets 80% threshold)
+  PUSH: confirms with user → pushed to origin
+  PR: opens #123 "Task #42 [analytics]: User metrics tracking"
+
+✓ Task 42 complete. PR: https://github.com/org/repo/pull/123
+  Run report: .taskmaster/reports/runs/2025-01-15-142033/
+```
+
+### Error Recovery: Failing tests timeout
+
+```bash
+$ tm autopilot 42
+→ Subtask 42.2 GREEN phase: attempt 1 fails (2 tests still red)
+→ Subtask 42.2 GREEN phase: attempt 2 fails (1 test still red)
+→ Subtask 42.2 GREEN phase: attempt 3 fails (1 test still red)
+
+⚠️  Paused: Could not achieve green state after 3 attempts
+📋 State saved to: .taskmaster/reports/runs/2025-01-15-142033/
+    Last error: "POST /api/metrics returns 500 instead of 201"
+
+Next steps:
+  - Review diff: git diff HEAD
+  - Inspect logs: cat .taskmaster/reports/runs/2025-01-15-142033/log.jsonl
+  - Check test output: cat .taskmaster/reports/runs/2025-01-15-142033/test-results/subtask-42.2-green-attempt3.json
+  - Resume after manual fix: tm autopilot --resume
+
+# Developer manually fixes the issue, then:
+$ tm autopilot --resume
+→ Resuming subtask 42.2 GREEN phase
+  GREEN: all tests pass
+  COMMIT: "feat(metrics): add collection endpoint (task 42.2)"
+→ Continuing to subtask 42.3...
+```
+
+### Dry Run: Preview before execution
+
+```bash
+$ tm autopilot 42 --dry-run
+Autopilot Plan for Task #42 [analytics]: User metrics tracking
+─────────────────────────────────────────────────────────────
+Preflight:
+  ✓ Working tree is clean
+  ✓ Test command detected: npm test
+  ✓ Tools available: git, gh, node, npm
+  ✓ Current branch: main (will create new branch)
+
+Branch & Tag:
+  → Create branch: analytics/task-42-user-metrics
+  → Set active tag: analytics
+
+Subtasks (3 pending):
+  1. 42.1: Add metrics schema
+     - RED: generate tests in src/__tests__/schema.test.js
+     - GREEN: implement src/schema.js
+     - COMMIT: "feat(metrics): add metrics schema (task 42.1)"
+
+  2. 42.2: Add collection endpoint [depends on 42.1]
+     - RED: generate tests in src/api/__tests__/metrics.test.js
+     - GREEN: implement src/api/metrics.js
+     - COMMIT: "feat(metrics): add collection endpoint (task 42.2)"
+
+  3. 42.3: Add dashboard widget [depends on 42.2]
+     - RED: generate tests in src/components/__tests__/MetricsWidget.test.jsx
+     - GREEN: implement src/components/MetricsWidget.jsx
+     - COMMIT: "feat(metrics): add dashboard widget (task 42.3)"
+
+Finalization:
+  → Run full test suite with coverage
+  → Push branch to origin (will confirm)
+  → Create PR targeting main
+
+Run without --dry-run to execute.
+```
+
+## 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.
+
+- 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.
+
+## TUI Layout (tmux-based)
+
+### Pane Structure
+
+```
+┌─────────────────────────────────────┬──────────────────────────────────┐
+│ Task Navigator (left)               │ Executor Terminal (right)        │
+│                                     │                                  │
+│ Project: my-app                     │ $ tm autopilot --executor-mode   │
+│ Branch: analytics/task-42           │ > Running subtask 42.2 GREEN...  │
+│ Tag: analytics                      │ > Implementing endpoint...       │
+│                                     │ > Tests: 3 passed, 0 failed      │
+│ Tasks:                              │ > Ready to commit                │
+│ → 42 [in-progress] User metrics     │                                  │
+│   → 42.1 [done] Schema              │ [Live output from Claude Code]   │
+│   → 42.2 [active] Endpoint ◀        │                                  │
+│   → 42.3 [pending] Dashboard        │                                  │
+│                                     │                                  │
+│ [s] start  [p] pause  [q] quit      │                                  │
+└─────────────────────────────────────┴──────────────────────────────────┘
+```
+
+### Implementation Notes
+
+- **Left pane**: `apps/cli/src/ui/tui/navigator.ts` (new, uses `blessed` or `ink`)
+- **Right pane**: spawned via `tmux split-window -h` running `tm autopilot --executor-mode`
+- **Communication**: shared state file `.taskmaster/state/current-run.json` + file watching or event stream
+- **Keybindings**:
+  - `s` - Start selected task
+  - `p` - Pause/resume current run
+  - `q` - Quit (with confirmation if run active)
+  - `↑/↓` - Navigate task list
+  - `Enter` - Expand/collapse subtasks
+
+## Prompt Composition (Detailed)
+
+### System Prompt Assembly
+
+Prompts are composed in three layers:
+
+1. **Base rules** (loaded in order from `.cursor/rules/` and `.claude/agents/`):
+   - `git_workflow.mdc` → git commit conventions, branch policy, PR guidelines
+   - `test_workflow.mdc` → TDD loop requirements, coverage thresholds, test structure
+   - `surgical-test-generator.md` → test generation methodology, project-specific test patterns
+
+2. **Task context injection**:
+   ```
+   You are implementing:
+   Task #42 [analytics]: User metrics tracking
+   Subtask 42.2: Add collection endpoint
+
+   Description:
+   Implement POST /api/metrics endpoint to collect user metrics events
+
+   Acceptance criteria:
+   - POST /api/metrics accepts { userId, eventType, timestamp }
+   - Validates input schema (reject missing/invalid fields)
+   - Persists to database
+   - Returns 201 on success with created record
+   - Returns 400 on validation errors
+
+   Dependencies:
+   - Subtask 42.1 (metrics schema) is complete
+
+   Current phase: RED (generate failing tests)
+   Test command: npm test
+   Test file convention: src/**/*.test.js (vitest framework detected)
+   Branch: analytics/task-42-user-metrics
+   Project language: JavaScript (Node.js)
+   ```
+
+3. **Phase-specific instructions**:
+   - **RED phase**: "Generate minimal failing tests for this subtask. Do NOT implement any production code. Only create test files. Confirm tests fail with clear error messages indicating missing implementation."
+   - **GREEN phase**: "Implement minimal code to pass the failing tests. Follow existing project patterns in `src/`. Only modify files necessary for this subtask. Keep changes focused and reviewable."
+
+### Example Full Prompt (RED Phase)
+
+```markdown
+<SYSTEM PROMPT>
+[Contents of .cursor/rules/git_workflow.mdc]
+[Contents of .cursor/rules/test_workflow.mdc]
+[Contents of .claude/agents/surgical-test-generator.md]
+
+<TASK CONTEXT>
+You are implementing:
+Task #42.2: Add collection endpoint
+
+Description:
+Implement POST /api/metrics endpoint to collect user metrics events
+
+Acceptance criteria:
+- POST /api/metrics accepts { userId, eventType, timestamp }
+- Validates input schema (reject missing/invalid fields)
+- Persists to database using MetricsSchema from subtask 42.1
+- Returns 201 on success with created record
+- Returns 400 on validation errors with details
+
+Dependencies: Subtask 42.1 (metrics schema) is complete
+
+<INSTRUCTION>
+Generate failing tests for this subtask. Follow project conventions:
+- Test file: src/api/__tests__/metrics.test.js
+- Framework: vitest (detected from package.json)
+- Test cases to cover:
+  * POST /api/metrics with valid payload → should return 201 (will fail: endpoint not implemented)
+  * POST /api/metrics with missing userId → should return 400 (will fail: validation not implemented)
+  * POST /api/metrics with invalid timestamp → should return 400 (will fail: validation not implemented)
+  * POST /api/metrics should persist to database → should save record (will fail: persistence not implemented)
+
+Do NOT implement the endpoint code yet. Only create test file(s).
+Confirm tests fail with messages like "Cannot POST /api/metrics" or "endpoint not defined".
+
+Output format:
+1. File path to create: src/api/__tests__/metrics.test.js
+2. Complete test code
+3. Command to run: npm test src/api/__tests__/metrics.test.js
+```
+
+### Example Full Prompt (GREEN Phase)
+
+```markdown
+<SYSTEM PROMPT>
+[Contents of .cursor/rules/git_workflow.mdc]
+[Contents of .cursor/rules/test_workflow.mdc]
+
+<TASK CONTEXT>
+Task #42.2: Add collection endpoint
+[same context as RED phase]
+
+<CURRENT STATE>
+Tests created in RED phase:
+- src/api/__tests__/metrics.test.js
+- 5 tests written, all failing as expected
+
+Test output:
+```
+FAIL src/api/__tests__/metrics.test.js
+  POST /api/metrics
+    ✗ should return 201 with valid payload (endpoint not found)
+    ✗ should return 400 with missing userId (endpoint not found)
+    ✗ should return 400 with invalid timestamp (endpoint not found)
+    ✗ should persist to database (endpoint not found)
+```
+
+<INSTRUCTION>
+Implement minimal code to make all tests pass.
+
+Guidelines:
+- Create/modify file: src/api/metrics.js
+- Use existing patterns from src/api/ (e.g., src/api/users.js for reference)
+- Import MetricsSchema from subtask 42.1 (src/models/schema.js)
+- Implement validation, persistence, and response handling
+- Follow project error handling conventions
+- Keep implementation focused on this subtask only
+
+After implementation:
+1. Run tests: npm test src/api/__tests__/metrics.test.js
+2. Confirm all 5 tests pass
+3. Report results
+
+Output format:
+1. File(s) created/modified
+2. Implementation code
+3. Test command and results
+```
+
+### Prompt Loading Configuration
+
+See `.taskmaster/config.json` → `prompts` section for paths and load order.
+
+## Configuration Schema
+
+### .taskmaster/config.json
+
+```json
+{
+  "autopilot": {
+    "enabled": true,
+    "requireCleanWorkingTree": true,
+    "commitTemplate": "{type}({scope}): {msg}",
+    "defaultCommitType": "feat",
+    "maxGreenAttempts": 3,
+    "testTimeout": 300000
+  },
+  "test": {
+    "runner": "auto",
+    "coverageThresholds": {
+      "lines": 80,
+      "branches": 80,
+      "functions": 80,
+      "statements": 80
+    },
+    "targetedRunPattern": "**/*.test.js"
+  },
+  "git": {
+    "branchPattern": "{tag}/task-{id}-{slug}",
+    "pr": {
+      "enabled": true,
+      "base": "default",
+      "bodyTemplate": ".taskmaster/templates/pr-body.md"
+    }
+  },
+  "prompts": {
+    "rulesPath": ".cursor/rules",
+    "testGeneratorPath": ".claude/agents/surgical-test-generator.md",
+    "loadOrder": ["git_workflow.mdc", "test_workflow.mdc"]
+  }
+}
+```
+
+### Configuration Fields
+
+#### autopilot
+- `enabled` (boolean): Enable/disable autopilot functionality
+- `requireCleanWorkingTree` (boolean): Require clean git state before starting
+- `commitTemplate` (string): Template for commit messages (tokens: `{type}`, `{scope}`, `{msg}`)
+- `defaultCommitType` (string): Default commit type (feat, fix, chore, etc.)
+- `maxGreenAttempts` (number): Maximum retry attempts to achieve green tests (default: 3)
+- `testTimeout` (number): Timeout in milliseconds per test run (default: 300000 = 5min)
+
+#### test
+- `runner` (string): Test runner detection mode (`"auto"` or explicit command like `"npm test"`)
+- `coverageThresholds` (object): Minimum coverage percentages required
+  - `lines`, `branches`, `functions`, `statements` (number): Threshold percentages (0-100)
+- `targetedRunPattern` (string): Glob pattern for targeted subtask test runs
+
+#### git
+- `branchPattern` (string): Branch naming pattern (tokens: `{tag}`, `{id}`, `{slug}`)
+- `pr.enabled` (boolean): Enable automatic PR creation
+- `pr.base` (string): Target branch for PRs (`"default"` uses repo default, or specify like `"main"`)
+- `pr.bodyTemplate` (string): Path to PR body template file (optional)
+
+#### prompts
+- `rulesPath` (string): Directory containing rule files (e.g., `.cursor/rules`)
+- `testGeneratorPath` (string): Path to test generator prompt file
+- `loadOrder` (array): Order to load rule files from `rulesPath`
+
+### Environment Variables
+
+```bash
+# Required for executor
+ANTHROPIC_API_KEY=sk-ant-...          # Claude API key
+
+# Optional: for PR creation
+GITHUB_TOKEN=ghp_...                  # GitHub personal access token
+
+# Optional: for other executors (future)
+OPENAI_API_KEY=sk-...
+GOOGLE_API_KEY=...
+```
+
+## Run Artifacts & Observability
+
+### Per-Run Artifact Structure
+
+Each autopilot run creates a timestamped directory with complete traceability:
+
+```
+.taskmaster/reports/runs/2025-01-15-142033/
+├── manifest.json          # run metadata (task id, start/end time, status)
+├── log.jsonl              # timestamped event stream
+├── commits.txt            # list of commit SHAs made during run
+├── test-results/
+│   ├── subtask-42.1-red.json
+│   ├── subtask-42.1-green.json
+│   ├── subtask-42.2-red.json
+│   ├── subtask-42.2-green-attempt1.json
+│   ├── subtask-42.2-green-attempt2.json
+│   ├── subtask-42.2-green-attempt3.json
+│   └── final-suite.json
+└── pr.md                  # generated PR body
+```
+
+### manifest.json Format
+
+```json
+{
+  "runId": "2025-01-15-142033",
+  "taskId": "42",
+  "tag": "analytics",
+  "branch": "analytics/task-42-user-metrics",
+  "startTime": "2025-01-15T14:20:33Z",
+  "endTime": "2025-01-15T14:45:12Z",
+  "status": "completed",
+  "subtasksCompleted": ["42.1", "42.2", "42.3"],
+  "subtasksFailed": [],
+  "totalCommits": 3,
+  "prUrl": "https://github.com/org/repo/pull/123",
+  "finalCoverage": {
+    "lines": 85.3,
+    "branches": 82.1,
+    "functions": 88.9,
+    "statements": 85.0
+  }
+}
+```
+
+### log.jsonl Format
+
+Event stream in JSON Lines format for easy parsing and debugging:
+
+```jsonl
+{"ts":"2025-01-15T14:20:33Z","phase":"preflight","status":"ok","details":{"testCmd":"npm test","gitClean":true}}
+{"ts":"2025-01-15T14:20:45Z","phase":"branch","status":"ok","branch":"analytics/task-42-user-metrics"}
+{"ts":"2025-01-15T14:21:00Z","phase":"red","subtask":"42.1","status":"ok","tests":{"failed":3,"passed":0}}
+{"ts":"2025-01-15T14:22:15Z","phase":"green","subtask":"42.1","status":"ok","tests":{"passed":3,"failed":0},"attempts":2}
+{"ts":"2025-01-15T14:22:20Z","phase":"commit","subtask":"42.1","status":"ok","sha":"a1b2c3d","message":"feat(metrics): add metrics schema (task 42.1)"}
+{"ts":"2025-01-15T14:23:00Z","phase":"red","subtask":"42.2","status":"ok","tests":{"failed":5,"passed":0}}
+{"ts":"2025-01-15T14:25:30Z","phase":"green","subtask":"42.2","status":"error","tests":{"passed":3,"failed":2},"attempts":3,"error":"Max attempts reached"}
+{"ts":"2025-01-15T14:25:35Z","phase":"pause","reason":"max_attempts","nextAction":"manual_review"}
+```
+
+### Test Results Format
+
+Each test run stores detailed results:
+
+```json
+{
+  "subtask": "42.2",
+  "phase": "green",
+  "attempt": 3,
+  "timestamp": "2025-01-15T14:25:30Z",
+  "command": "npm test src/api/__tests__/metrics.test.js",
+  "exitCode": 1,
+  "duration": 2340,
+  "summary": {
+    "total": 5,
+    "passed": 3,
+    "failed": 2,
+    "skipped": 0
+  },
+  "failures": [
+    {
+      "test": "POST /api/metrics should return 201 with valid payload",
+      "error": "Expected status 201, got 500",
+      "stack": "..."
+    }
+  ],
+  "coverage": {
+    "lines": 78.5,
+    "branches": 75.0,
+    "functions": 80.0,
+    "statements": 78.5
+  }
+}
+```
+
+## Execution Model
+
+### Orchestration vs Direct Execution
+
+The autopilot system uses an **orchestration model** rather than direct code execution:
+
+**Orchestrator Role** (tm-core WorkflowOrchestrator):
+- Maintains state machine tracking current phase (RED/GREEN/COMMIT) per subtask
+- Validates preconditions (tests pass, git state clean, etc.)
+- Returns "work units" describing what needs to be done next
+- Records completion and advances to next phase
+- Persists state for resumability
+
+**Executor Role** (Claude Code/AI session via MCP):
+- Queries orchestrator for next work unit
+- Executes the work (generates tests, writes code, runs tests, makes commits)
+- Reports results back to orchestrator
+- Handles file operations and tool invocations
+
+**Why This Approach?**
+- Leverages existing AI capabilities (Claude Code) rather than duplicating them
+- MCP protocol provides clean separation between state management and execution
+- Allows human oversight and intervention at each phase
+- Simpler to implement: orchestrator is pure state logic, no code generation needed
+- Enables multiple executor types (Claude Code, other AI tools, human developers)
+
+**Example Flow**:
+```typescript
+// Claude Code (via MCP) queries orchestrator
+const workUnit = await orchestrator.getNextWorkUnit('42');
+// => {
+//      phase: 'RED',
+//      subtask: '42.1',
+//      action: 'Generate failing tests for metrics schema',
+//      context: { title, description, dependencies, testFile: 'src/__tests__/schema.test.js' }
+//    }
+
+// Claude Code executes the work (writes test file, runs tests)
+// Then reports back
+await orchestrator.completeWorkUnit('42', '42.1', 'RED', {
+  success: true,
+  testsCreated: ['src/__tests__/schema.test.js'],
+  testsFailed: 3
+});
+
+// Query again for next phase
+const nextWorkUnit = await orchestrator.getNextWorkUnit('42');
+// => { phase: 'GREEN', subtask: '42.1', action: 'Implement code to pass tests', ... }
+```
+
+## Design Decisions
+
+### Why commit per subtask instead of per task?
+
+**Decision**: Commit after each subtask's green state, not after the entire task.
+
+**Rationale**:
+- Atomic commits make code review easier (reviewers can see logical progression)
+- Easier to revert a single subtask if it causes issues downstream
+- Matches the TDD loop's natural checkpoint and cognitive boundary
+- Provides resumability points if the run is interrupted
+
+**Trade-off**: More commits per task (can use squash-merge in PRs if desired)
+
+### Why not support parallel subtask execution?
+
+**Decision**: Sequential subtask execution in Phase 1; parallel execution deferred to Phase 3.
+
+**Rationale**:
+- Subtasks often have implicit dependencies (e.g., schema before endpoint, endpoint before UI)
+- Simpler orchestrator state machine (less complexity = faster to ship)
+- Parallel execution requires explicit dependency DAG and conflict resolution
+- Can be added in Phase 3 once core workflow is proven stable
+
+**Trade-off**: Slower for truly independent subtasks (mitigated by keeping subtasks small and focused)
+
+### Why require 80% coverage by default?
+
+**Decision**: Enforce 80% coverage threshold (lines/branches/functions/statements) before allowing commits.
+
+**Rationale**:
+- Industry standard baseline for production code quality
+- Forces test generation to be comprehensive, not superficial
+- Configurable per project via `.taskmaster/config.json` if too strict
+- Prevents "green tests" that only test happy paths
+
+**Trade-off**: May require more test generation iterations; can be lowered per project
+
+### Why use tmux instead of a rich GUI?
+
+**Decision**: MVP uses tmux split panes for TUI, not Electron/web-based GUI.
+
+**Rationale**:
+- Tmux is universally available on dev machines; no installation burden
+- Terminal-first workflows match developer mental model (no context switching)
+- Simpler to implement and maintain; can add GUI later via extensions
+- State stored in files allows IDE/extension integration without coupling
+
+**Trade-off**: Less visual polish than GUI; requires tmux familiarity
+
+### Why not support multiple executors (codex/gemini/claude) in Phase 1?
+
+**Decision**: Start with Claude executor only; add others in Phase 2+.
+
+**Rationale**:
+- Reduces scope and complexity for initial delivery
+- Claude Code already integrated with existing executor service
+- Executor abstraction already exists; adding more is straightforward later
+- Different executors may need different prompt strategies (requires experimentation)
+
+**Trade-off**: Users locked to Claude initially; can work around with manual executor selection
+
+## 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 (State Machine & Orchestration)
+
+  - Implement WorkflowOrchestrator in tm-core as a **state machine** that tracks TDD phases per subtask.
+
+  - Orchestrator **guides** the current AI session (Claude Code/MCP client) rather than executing code itself.
+
+  - Add Git/Test adapters for status checks and validation (not direct execution).
+
+  - WorkflowOrchestrator API:
+    - `getNextWorkUnit(taskId)` → returns next phase to execute (RED/GREEN/COMMIT) with context
+    - `completeWorkUnit(taskId, subtaskId, phase, result)` → records completion and advances state
+    - `getRunState(taskId)` → returns current progress and resumability data
+
+  - MCP integration: expose work unit endpoints so Claude Code can query "what to do next" and report back.
+
+  - Branch/tag mapping via existing tag-management APIs.
+
+  - Run report persisted under .taskmaster/reports/runs/ with state checkpoints for resumability.
+
+- 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-tm-start.txt

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

.taskmaster/docs/research/2025-08-01_do-we-need-to-add-new-commands-or-can-we-just-weap.md

@@ -0,0 +1,153 @@
+---
+title: Research Session
+query: "do we need to add new commands or can we just weaponize the gh cli tool"
+date: 2025-08-01
+time: 2:27:52 p.m.
+timestamp: 2025-08-01T11:27:52.249Z
+exchanges: 3
+---
+
+# Research Session
+
+## Initial Query
+
+**Question:** do we need to add new commands or can we just weaponize the gh cli tool
+
+**Response:**
+
+For the implementation of the `task-master git` command suite to automate git workflows (Task 97), it is possible to leverage the existing **GitHub CLI (`gh`) tool** rather than creating entirely new git commands from scratch. The GitHub CLI provides a rich set of commands that cover many GitHub-related operations such as branch management, pull request handling, workflow triggering, and release management, which can be scripted and integrated into your CLI tool[1][2][3][4].
+
+### Key Points Supporting Weaponizing GitHub CLI:
+
+- **Comprehensive GitHub Operations**: The `gh` CLI supports creating branches, managing pull requests, releases, tags, and even triggering and monitoring GitHub Actions workflows. This aligns well with the requirements of automated branch management, commit generation, and PR description generation in Task 97[1][3].
+
+- **Scripting and Automation Friendly**: GitHub CLI commands can be scripted and integrated into custom workflows or CLI tools. You can create aliases or wrap `gh` commands inside your own CLI commands to provide a seamless user experience while relying on the battle-tested GitHub CLI for underlying operations[1][3].
+
+- **Authentication and Permissions**: `gh` uses environment variables like `GH_TOKEN` or `GITHUB_TOKEN` for authentication, which can be securely managed in CI/CD pipelines or local environments. This simplifies integration without needing to implement custom authentication logic[3][4].
+
+- **Extensibility**: If some specific git workflow features are not directly supported by `gh`, you can extend it with custom scripts or combine it with native git commands. This hybrid approach reduces the need to reinvent core git operations while allowing customization[1].
+
+### Considerations for Your Project:
+
+- Since Task 97 requires **automated branch management** (branch creation, validation, switching, cleanup), **intelligent commit generation**, and **PR description generation**, you can implement these by invoking `gh` commands programmatically within your `task-master git` commands.
+
+- For example, branch creation and switching can be done with native git commands wrapped in your CLI, while PR creation and management can be handled via `gh pr create`, `gh pr merge`, etc.
+
+- You may still need to implement some **custom logic** for commit type detection, branch name validation, and PR description generation based on your task metadata, but the underlying git and GitHub operations can be delegated to `gh`.
+
+- This approach aligns with your existing CLI foundation (Task 2) and leverages a well-supported tool, reducing development effort and increasing reliability.
+
+### Summary
+
+You **do not necessarily need to add entirely new git commands** for Task 97. Instead, you can **weaponize the GitHub CLI (`gh`) tool** by wrapping and scripting its commands within your `task-master git` command suite. This will allow you to automate git workflows efficiently, maintain consistency, and leverage GitHub’s API capabilities without reinventing the wheel[1][2][3][4].
+
+If there are gaps in `gh` functionality for your specific workflow needs, you can supplement with native git commands or custom scripts, but the core git and GitHub operations should be handled by `gh` for best results.
+
+---
+
+## Follow-up 1
+
+**Question:** how does this relate to git worktrees? i hear that they get super complicated when trying to implement them.
+
+**Response:**
+
+Git worktrees allow you to have multiple working directories attached to the same Git repository, each checked out to different branches simultaneously. This enables parallel development workflows without the overhead of cloning the repository multiple times or constantly switching branches in a single working directory[2][3].
+
+However, **implementing or managing git worktrees can get complicated** for several reasons:
+
+- **Complexity for users and tooling:** Managing multiple active worktrees requires careful tracking of which directory corresponds to which branch. This can be confusing and error-prone, especially for novices or when many worktrees are in use simultaneously. Mistakes like committing to the wrong branch or working in the wrong directory are common risks[1].
+
+- **Maintenance overhead:** Worktrees accumulate over time and need to be pruned or cleaned up regularly (`git worktree prune`) to avoid clutter and potential confusion. This adds an extra maintenance step to the workflow[1].
+
+- **Syncing and update challenges:** Each worktree is a separate checkout and can become outdated if not regularly updated from the main repository. This can lead to merge conflicts or redundant work if branches diverge significantly[1].
+
+- **Tooling and integration limitations:** Not all Git tools, scripts, or GUIs fully support worktrees or are optimized for them. This can cause inconsistencies or require additional custom tooling to manage worktrees effectively[1].
+
+- **Performance considerations:** Managing multiple worktrees simultaneously can have performance implications, especially in very large repositories, due to the overhead of maintaining multiple checkouts and metadata[1].
+
+In the context of your project, which involves automating git workflows and possibly wrapping or extending git/GitHub CLI commands, these complexities imply:
+
+- If you consider supporting git worktrees in your `task-master git` command suite, you will need to handle the complexity of managing multiple directories and branches carefully.
+
+- You might need to implement additional logic or tooling to track and manage worktrees, avoid user confusion, and ensure synchronization between them.
+
+- Since your project already plans to leverage the GitHub CLI (`gh`) and native git commands, you could integrate worktree commands (`git worktree add`, `git worktree remove`, `git worktree list`) but should be prepared for the added complexity in workflow management and user documentation.
+
+- Custom wrappers or managers (like the one described in [3]) can help reduce friction by automating worktree creation, switching, and cleanup, which might be a useful approach to consider.
+
+Overall, **git worktrees provide powerful parallel branch management but introduce complexity in implementation and user experience** that must be carefully managed through tooling, automation, and clear documentation[1][3][4].
+
+---
+
+**Summary Table of Git Worktree Challenges and Considerations**
+
+| Aspect                  | Description                                                                                   | Implication for Project                                  |
+|-------------------------|-----------------------------------------------------------------------------------------------|----------------------------------------------------------|
+| User Complexity         | Confusing multiple directories and branches                                                  | Need clear UI/UX and safeguards                          |
+| Maintenance Overhead    | Requires pruning and cleanup of stale worktrees                                              | Automate cleanup or provide commands                     |
+| Syncing Issues         | Worktrees can become outdated or diverge                                                     | Implement update checks and sync workflows               |
+| Tooling Support        | Limited support in some Git tools and GUIs                                                  | May require custom tooling or wrappers                   |
+| Performance            | Overhead in large repos with many worktrees                                                 | Monitor and optimize performance                          |
+| Workflow Automation    | Manual worktree management is tedious                                                       | Build custom managers or wrappers to simplify usage     |
+
+---
+
+Given your project’s focus on automating git workflows and leveraging existing CLI tools, **implementing git worktree support is feasible but will require careful design to handle these complexities effectively**. You may want to start with basic worktree commands and incrementally add automation and safeguards as needed.
+
+---
+
+## Follow-up 2
+
+**Question:** since we already have a way to have separated task lists per branch, couldn't we do the same thing for worktrees? each taskmaster list (tag) would have its own worktree based on the name of the tag?
+
+**Response:**
+
+Yes, you can apply a similar approach used for separated task lists per branch to git worktrees by associating each taskmaster list (tag) with its own git worktree named after the tag. This means each tag would correspond to a dedicated worktree directory checked out to a branch or commit related to that tag, enabling isolated parallel work environments for each task list.
+
+### How This Maps to Git Worktrees
+
+- **Git worktrees** allow multiple working directories linked to the same repository, each checked out to a different branch or commit[1][2]. This lets you work on multiple branches simultaneously without switching contexts in a single directory.
+
+- When you create a worktree with `git worktree add <path> [<branch>]`, Git creates a new linked working tree at `<path>`, optionally checking out a specified branch or creating a new one[1][2]. Naming the worktree directory after the tag (taskmaster list) is straightforward and semantically clear.
+
+- This setup mirrors your existing branch-based task list separation but extends it to physical directories, which can improve workflow isolation and reduce context switching.
+
+### Benefits for Your Project
+
+- **Isolated environments per task list/tag:** Each tag’s worktree can have its own checked-out branch, allowing independent development, testing, or review without interference.
+
+- **Parallel workflows:** Developers can switch between worktrees (directories) instead of switching branches in one directory, reducing errors and improving productivity.
+
+- **Automation potential:** Your `task-master git` commands can automate creating, switching, and cleaning up these worktrees based on tags, similar to how you manage branches and task lists.
+
+### Challenges and Considerations
+
+- **Complexity in management:** Git worktrees add complexity in tracking multiple directories and ensuring users operate in the correct one[1]. Your CLI should provide clear commands and feedback to avoid confusion.
+
+- **Maintenance overhead:** Worktrees need pruning and cleanup (`git worktree prune` or `git worktree remove`) to avoid clutter[1]. Automating cleanup in your tool would be beneficial.
+
+- **Syncing and updates:** Each worktree is a separate checkout and can become outdated. Your automation should include commands to update or rebase worktrees as needed.
+
+- **Tooling support:** Not all Git tools or scripts fully support worktrees, so your CLI wrappers should handle edge cases and provide a consistent experience[1][3].
+
+### Practical Implementation Ideas
+
+- When a new tag (taskmaster list) is created, run `git worktree add` to create a new worktree directory named after the tag.
+
+- Store metadata linking tags to worktree paths in your taskmaster configuration to track and manage them.
+
+- Provide commands like `task-master worktree list`, `task-master worktree add <tag>`, and `task-master worktree remove <tag>` to manage these worktrees.
+
+- Integrate with GitHub CLI (`gh`) and native git commands to automate branch creation, PR handling, and syncing within each worktree.
+
+- Consider inspiration from existing tools like [wt](https://github.com/taecontrol/wt) that automate worktree environment setup and teardown[3].
+
+### Summary
+
+Using git worktrees per taskmaster tag is a feasible and potentially powerful extension of your current branch-based task list separation. It offers isolated, parallel working directories aligned with your tags, improving workflow clarity and reducing branch-switching overhead. However, it requires careful tooling and automation to manage complexity, maintenance, and synchronization effectively. Given your project’s focus on automating git workflows and leveraging CLI tools, implementing this feature incrementally with robust user feedback and cleanup commands would be a practical approach.
+
+
+---
+
+*Generated by Task Master Research Command*  
+*Timestamp: 2025-08-01T11:27:52.249Z*

.taskmaster/docs/tdd-workflow-phase-0-spike.md

@@ -0,0 +1,130 @@
+# Phase 0: Spike - Autonomous TDD Workflow ✅ COMPLETE
+
+## Objective
+Validate feasibility and build foundational understanding before full implementation.
+
+## Status
+**COMPLETED** - All deliverables implemented and validated.
+
+See `apps/cli/src/commands/autopilot.command.ts` for implementation.
+
+## Scope
+- Implement CLI skeleton `tm autopilot` with dry-run mode
+- Show planned steps from a real task with subtasks
+- Detect test runner from package.json
+- Detect git state and render preflight report
+
+## Deliverables
+
+### 1. CLI Command Skeleton
+- Create `apps/cli/src/commands/autopilot.command.ts`
+- Support `tm autopilot <taskId>` command
+- Implement `--dry-run` flag
+- Basic help text and usage information
+
+### 2. Preflight Detection System
+- Detect test runner from package.json (npm test, pnpm test, etc.)
+- Check git working tree state (clean/dirty)
+- Validate required tools are available (git, gh, node/npm)
+- Detect default branch
+
+### 3. Dry-Run Execution Plan Display
+Display planned execution for a task including:
+- Preflight checks status
+- Branch name that would be created
+- Tag that would be set
+- List of subtasks in execution order
+- For each subtask:
+  - RED phase: test file that would be created
+  - GREEN phase: implementation files that would be modified
+  - COMMIT: commit message that would be used
+- Finalization steps: test suite run, coverage check, push, PR creation
+
+### 4. Task Loading & Validation
+- Load task from TaskMaster state
+- Validate task exists and has subtasks
+- If no subtasks, show message about needing to expand first
+- Show dependency order for subtasks
+
+## Example Output
+
+```bash
+$ tm autopilot 42 --dry-run
+
+Autopilot Plan for Task #42 [analytics]: User metrics tracking
+─────────────────────────────────────────────────────────────
+
+Preflight Checks:
+  ✓ Working tree is clean
+  ✓ Test command detected: npm test
+  ✓ Tools available: git, gh, node, npm
+  ✓ Current branch: main (will create new branch)
+  ✓ Task has 3 subtasks ready to execute
+
+Branch & Tag:
+  → Will create branch: analytics/task-42-user-metrics
+  → Will set active tag: analytics
+
+Execution Plan (3 subtasks):
+
+  1. Subtask 42.1: Add metrics schema
+     RED:    Generate tests → src/__tests__/schema.test.js
+     GREEN:  Implement code → src/schema.js
+     COMMIT: "feat(metrics): add metrics schema (task 42.1)"
+
+  2. Subtask 42.2: Add collection endpoint [depends on 42.1]
+     RED:    Generate tests → src/api/__tests__/metrics.test.js
+     GREEN:  Implement code → src/api/metrics.js
+     COMMIT: "feat(metrics): add collection endpoint (task 42.2)"
+
+  3. Subtask 42.3: Add dashboard widget [depends on 42.2]
+     RED:    Generate tests → src/components/__tests__/MetricsWidget.test.jsx
+     GREEN:  Implement code → src/components/MetricsWidget.jsx
+     COMMIT: "feat(metrics): add dashboard widget (task 42.3)"
+
+Finalization:
+  → Run full test suite with coverage (threshold: 80%)
+  → Push branch to origin (will confirm)
+  → Create PR targeting main
+
+Estimated commits: 3
+Estimated duration: ~20-30 minutes (depends on implementation complexity)
+
+Run without --dry-run to execute.
+```
+
+## Success Criteria
+- Dry-run output is clear and matches expected workflow
+- Preflight detection works correctly on the project repo
+- Task loading integrates with existing TaskMaster state
+- No actual git operations or file modifications occur in dry-run mode
+
+## Out of Scope
+- Actual test generation
+- Actual code implementation
+- Git operations (branch creation, commits, push)
+- PR creation
+- Test execution
+
+## Implementation Notes
+- Reuse existing `TaskService` from `packages/tm-core`
+- Use existing git utilities from `scripts/modules/utils/git-utils.js`
+- Load task/subtask data from `.taskmaster/tasks/tasks.json`
+- Detect test command via package.json → scripts.test field
+
+## Dependencies
+- Existing TaskMaster CLI structure
+- Existing task storage format
+- Git utilities
+
+## Estimated Effort
+2-3 days
+
+## Validation
+Test dry-run mode with:
+- Task with 1 subtask
+- Task with multiple subtasks
+- Task with dependencies between subtasks
+- Task without subtasks (should show warning)
+- Dirty git working tree (should warn)
+- Missing tools (should error with helpful message)

.taskmaster/docs/tdd-workflow-phase-1-orchestrator.md

@@ -0,0 +1,369 @@
+# Phase 1: Core Rails - State Machine & Orchestration
+
+## Objective
+Build the WorkflowOrchestrator as a state machine that guides AI sessions through TDD workflow, rather than directly executing code.
+
+## Architecture Overview
+
+### Execution Model
+The orchestrator acts as a **state manager and guide**, not a code executor:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Claude Code (MCP Client)                  │
+│  - Queries "what to do next"                                │
+│  - Executes work (writes tests, code, runs commands)        │
+│  - Reports completion                                        │
+└────────────────┬────────────────────────────────────────────┘
+                 │ MCP Protocol
+                 ▼
+┌─────────────────────────────────────────────────────────────┐
+│              WorkflowOrchestrator (tm-core)                  │
+│  - Maintains state machine (RED → GREEN → COMMIT)           │
+│  - Returns work units with context                          │
+│  - Validates preconditions                                  │
+│  - Records progress                                         │
+│  - Persists state for resumability                          │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Why This Approach?
+1. **Separation of Concerns**: State management separate from code execution
+2. **Leverage Existing Tools**: Uses Claude Code's capabilities instead of reimplementing
+3. **Human-in-the-Loop**: Easy to inspect state and intervene at any phase
+4. **Simpler Implementation**: Orchestrator is pure logic, no AI model integration needed
+5. **Flexible Executors**: Any tool (Claude Code, human, other AI) can execute work units
+
+## Core Components
+
+### 1. WorkflowOrchestrator Service
+**Location**: `packages/tm-core/src/services/workflow-orchestrator.service.ts`
+
+**Responsibilities**:
+- Track current phase (RED/GREEN/COMMIT) per subtask
+- Generate work units with context for each phase
+- Validate phase completion criteria
+- Advance state machine on successful completion
+- Handle errors and retry logic
+- Persist run state for resumability
+
+**API**:
+```typescript
+interface WorkflowOrchestrator {
+  // Start a new autopilot run
+  startRun(taskId: string, options?: RunOptions): Promise<RunContext>;
+
+  // Get next work unit to execute
+  getNextWorkUnit(runId: string): Promise<WorkUnit | null>;
+
+  // Report work unit completion
+  completeWorkUnit(
+    runId: string,
+    workUnitId: string,
+    result: WorkUnitResult
+  ): Promise<void>;
+
+  // Get current run state
+  getRunState(runId: string): Promise<RunState>;
+
+  // Pause/resume
+  pauseRun(runId: string): Promise<void>;
+  resumeRun(runId: string): Promise<void>;
+}
+
+interface WorkUnit {
+  id: string;                    // Unique work unit ID
+  phase: 'RED' | 'GREEN' | 'COMMIT';
+  subtaskId: string;             // e.g., "42.1"
+  action: string;                // Human-readable description
+  context: WorkUnitContext;      // All info needed to execute
+  preconditions: Precondition[]; // Checks before execution
+}
+
+interface WorkUnitContext {
+  taskId: string;
+  taskTitle: string;
+  subtaskTitle: string;
+  subtaskDescription: string;
+  dependencies: string[];        // Completed subtask IDs
+  testCommand: string;           // e.g., "npm test"
+
+  // Phase-specific context
+  redPhase?: {
+    testFile: string;            // Where to create test
+    testFramework: string;       // e.g., "vitest"
+    acceptanceCriteria: string[];
+  };
+
+  greenPhase?: {
+    testFile: string;            // Test to make pass
+    implementationHints: string[];
+    expectedFiles: string[];     // Files likely to modify
+  };
+
+  commitPhase?: {
+    commitMessage: string;       // Pre-generated message
+    filesToCommit: string[];     // Files modified in RED+GREEN
+  };
+}
+
+interface WorkUnitResult {
+  success: boolean;
+  phase: 'RED' | 'GREEN' | 'COMMIT';
+
+  // RED phase results
+  testsCreated?: string[];
+  testsFailed?: number;
+
+  // GREEN phase results
+  testsPassed?: number;
+  filesModified?: string[];
+  attempts?: number;
+
+  // COMMIT phase results
+  commitSha?: string;
+
+  // Common
+  error?: string;
+  logs?: string;
+}
+
+interface RunState {
+  runId: string;
+  taskId: string;
+  status: 'running' | 'paused' | 'completed' | 'failed';
+  currentPhase: 'RED' | 'GREEN' | 'COMMIT';
+  currentSubtask: string;
+  completedSubtasks: string[];
+  failedSubtasks: string[];
+  startTime: Date;
+  lastUpdateTime: Date;
+
+  // Resumability
+  checkpoint: {
+    subtaskId: string;
+    phase: 'RED' | 'GREEN' | 'COMMIT';
+    attemptNumber: number;
+  };
+}
+```
+
+### 2. State Machine Logic
+
+**Phase Transitions**:
+```
+START → RED(subtask 1) → GREEN(subtask 1) → COMMIT(subtask 1)
+                                               ↓
+                        RED(subtask 2) ← ─ ─ ─ ┘
+                             ↓
+                        GREEN(subtask 2)
+                             ↓
+                        COMMIT(subtask 2)
+                             ↓
+                           (repeat for remaining subtasks)
+                             ↓
+                        FINALIZE → END
+```
+
+**Phase Rules**:
+- **RED**: Can only transition to GREEN if tests created and failing
+- **GREEN**: Can only transition to COMMIT if tests passing (attempt < maxAttempts)
+- **COMMIT**: Can only transition to next RED if commit successful
+- **FINALIZE**: Can only start if all subtasks completed
+
+**Preconditions**:
+- RED: No uncommitted changes (or staged from previous GREEN that failed)
+- GREEN: RED phase complete, tests exist and are failing
+- COMMIT: GREEN phase complete, all tests passing, coverage meets threshold
+
+### 3. MCP Integration
+
+**New MCP Tools** (expose WorkflowOrchestrator via MCP):
+```typescript
+// Start an autopilot run
+mcp__task_master_ai__autopilot_start(taskId: string, dryRun?: boolean)
+
+// Get next work unit
+mcp__task_master_ai__autopilot_next_work_unit(runId: string)
+
+// Complete current work unit
+mcp__task_master_ai__autopilot_complete_work_unit(
+  runId: string,
+  workUnitId: string,
+  result: WorkUnitResult
+)
+
+// Get run state
+mcp__task_master_ai__autopilot_get_state(runId: string)
+
+// Pause/resume
+mcp__task_master_ai__autopilot_pause(runId: string)
+mcp__task_master_ai__autopilot_resume(runId: string)
+```
+
+### 4. Git/Test Adapters
+
+**GitAdapter** (`packages/tm-core/src/services/git-adapter.service.ts`):
+- Check working tree status
+- Validate branch state
+- Read git config (user, remote, default branch)
+- **Does NOT execute** git commands (that's executor's job)
+
+**TestAdapter** (`packages/tm-core/src/services/test-adapter.service.ts`):
+- Detect test framework from package.json
+- Parse test output (failures, passes, coverage)
+- Validate coverage thresholds
+- **Does NOT run** tests (that's executor's job)
+
+### 5. Run State Persistence
+
+**Storage Location**: `.taskmaster/reports/runs/<runId>/`
+
+**Files**:
+- `state.json` - Current run state (for resumability)
+- `log.jsonl` - Event stream (timestamped work unit completions)
+- `manifest.json` - Run metadata
+- `work-units.json` - All work units generated for this run
+
+**Example `state.json`**:
+```json
+{
+  "runId": "2025-01-15-142033",
+  "taskId": "42",
+  "status": "paused",
+  "currentPhase": "GREEN",
+  "currentSubtask": "42.2",
+  "completedSubtasks": ["42.1"],
+  "failedSubtasks": [],
+  "checkpoint": {
+    "subtaskId": "42.2",
+    "phase": "GREEN",
+    "attemptNumber": 2
+  },
+  "startTime": "2025-01-15T14:20:33Z",
+  "lastUpdateTime": "2025-01-15T14:35:12Z"
+}
+```
+
+## Implementation Plan
+
+### Step 1: WorkflowOrchestrator Skeleton
+- [ ] Create `workflow-orchestrator.service.ts` with interfaces
+- [ ] Implement state machine logic (phase transitions)
+- [ ] Add run state persistence (state.json, log.jsonl)
+- [ ] Write unit tests for state machine
+
+### Step 2: Work Unit Generation
+- [ ] Implement `getNextWorkUnit()` with context assembly
+- [ ] Generate RED phase work units (test file paths, criteria)
+- [ ] Generate GREEN phase work units (implementation hints)
+- [ ] Generate COMMIT phase work units (commit messages)
+
+### Step 3: Git/Test Adapters
+- [ ] Create GitAdapter for status checks only
+- [ ] Create TestAdapter for output parsing only
+- [ ] Add precondition validation using adapters
+- [ ] Write adapter unit tests
+
+### Step 4: MCP Integration
+- [ ] Add MCP tool definitions in `packages/mcp-server/src/tools/`
+- [ ] Wire up WorkflowOrchestrator to MCP tools
+- [ ] Test MCP tools via Claude Code
+- [ ] Document MCP workflow in CLAUDE.md
+
+### Step 5: CLI Integration
+- [ ] Update `autopilot.command.ts` to call WorkflowOrchestrator
+- [ ] Add `--interactive` mode that shows work units and waits for completion
+- [ ] Add `--resume` flag to continue paused runs
+- [ ] Test end-to-end flow
+
+### Step 6: Integration Testing
+- [ ] Create test task with 2-3 subtasks
+- [ ] Run autopilot start → get work unit → complete → repeat
+- [ ] Verify state persistence and resumability
+- [ ] Test failure scenarios (test failures, git issues)
+
+## Success Criteria
+- [ ] WorkflowOrchestrator can generate work units for all phases
+- [ ] MCP tools allow Claude Code to query and complete work units
+- [ ] State persists correctly between work unit completions
+- [ ] Run can be paused and resumed from checkpoint
+- [ ] Adapters validate preconditions without executing commands
+- [ ] End-to-end: Claude Code can complete a simple task via work units
+
+## Out of Scope (Phase 1)
+- Actual git operations (branch creation, commits) - executor handles this
+- Actual test execution - executor handles this
+- PR creation - deferred to Phase 2
+- TUI interface - deferred to Phase 3
+- Coverage enforcement - deferred to Phase 2
+
+## Example Usage Flow
+
+```bash
+# Terminal 1: Claude Code session
+$ claude
+
+# In Claude Code (via MCP):
+> Start autopilot for task 42
+[Calls mcp__task_master_ai__autopilot_start(42)]
+→ Run started: run-2025-01-15-142033
+
+> Get next work unit
+[Calls mcp__task_master_ai__autopilot_next_work_unit(run-2025-01-15-142033)]
+→ Work unit: RED phase for subtask 42.1
+→ Action: Generate failing tests for metrics schema
+→ Test file: src/__tests__/schema.test.js
+→ Framework: vitest
+
+> [Claude Code creates test file, runs tests]
+
+> Complete work unit
+[Calls mcp__task_master_ai__autopilot_complete_work_unit(
+  run-2025-01-15-142033,
+  workUnit-42.1-RED,
+  { success: true, testsCreated: ['src/__tests__/schema.test.js'], testsFailed: 3 }
+)]
+→ Work unit completed. State saved.
+
+> Get next work unit
+[Calls mcp__task_master_ai__autopilot_next_work_unit(run-2025-01-15-142033)]
+→ Work unit: GREEN phase for subtask 42.1
+→ Action: Implement code to pass failing tests
+→ Test file: src/__tests__/schema.test.js
+→ Expected implementation: src/schema.js
+
+> [Claude Code implements schema.js, runs tests, confirms all pass]
+
+> Complete work unit
+[...]
+→ Work unit completed. Ready for COMMIT.
+
+> Get next work unit
+[...]
+→ Work unit: COMMIT phase for subtask 42.1
+→ Commit message: "feat(metrics): add metrics schema (task 42.1)"
+→ Files to commit: src/__tests__/schema.test.js, src/schema.js
+
+> [Claude Code stages files and commits]
+
+> Complete work unit
+[...]
+→ Subtask 42.1 complete! Moving to 42.2...
+```
+
+## Dependencies
+- Existing TaskService (task loading, status updates)
+- Existing PreflightChecker (environment validation)
+- Existing TaskLoaderService (dependency ordering)
+- MCP server infrastructure
+
+## Estimated Effort
+7-10 days
+
+## Next Phase
+Phase 2 will add:
+- PR creation via gh CLI
+- Coverage enforcement
+- Enhanced error recovery
+- Full resumability testing

.taskmaster/docs/tdd-workflow-phase-2-pr-resumability.md

@@ -0,0 +1,433 @@
+# Phase 2: PR + Resumability - Autonomous TDD Workflow
+
+## Objective
+Add PR creation with GitHub CLI integration, resumable checkpoints for interrupted runs, and enhanced guardrails with coverage enforcement.
+
+## Scope
+- GitHub PR creation via `gh` CLI
+- Well-formed PR body using run report
+- Resumable checkpoints and `--resume` flag
+- Coverage enforcement before finalization
+- Optional lint/format step
+- Enhanced error recovery
+
+## Deliverables
+
+### 1. PR Creation Integration
+
+**PRAdapter** (`packages/tm-core/src/services/pr-adapter.ts`):
+```typescript
+class PRAdapter {
+  async isGHAvailable(): Promise<boolean>
+  async createPR(options: PROptions): Promise<PRResult>
+  async getPRTemplate(runReport: RunReport): Promise<string>
+
+  // Fallback for missing gh CLI
+  async getManualPRInstructions(options: PROptions): Promise<string>
+}
+
+interface PROptions {
+  branch: string
+  base: string
+  title: string
+  body: string
+  draft?: boolean
+}
+
+interface PRResult {
+  url: string
+  number: number
+}
+```
+
+**PR Title Format:**
+```
+Task #<id> [<tag>]: <title>
+```
+
+Example: `Task #42 [analytics]: User metrics tracking`
+
+**PR Body Template:**
+
+Located at `.taskmaster/templates/pr-body.md`:
+
+```markdown
+## Summary
+
+Implements Task #42 from TaskMaster autonomous workflow.
+
+**Branch:** {branch}
+**Tag:** {tag}
+**Subtasks completed:** {subtaskCount}
+
+{taskDescription}
+
+## Subtasks
+
+{subtasksList}
+
+## Test Coverage
+
+| Metric | Coverage |
+|--------|----------|
+| Lines | {lines}% |
+| Branches | {branches}% |
+| Functions | {functions}% |
+| Statements | {statements}% |
+
+**All subtasks passed with {totalTests} tests.**
+
+## Commits
+
+{commitsList}
+
+## Run Report
+
+Full execution report: `.taskmaster/reports/runs/{runId}/`
+
+---
+
+🤖 Generated with [Task Master](https://github.com/cline/task-master) autonomous TDD workflow
+```
+
+**Token replacement:**
+- `{branch}` → branch name
+- `{tag}` → active tag
+- `{subtaskCount}` → number of completed subtasks
+- `{taskDescription}` → task description from TaskMaster
+- `{subtasksList}` → markdown list of subtask titles
+- `{lines}`, `{branches}`, `{functions}`, `{statements}` → coverage percentages
+- `{totalTests}` → total test count
+- `{commitsList}` → markdown list of commit SHAs and messages
+- `{runId}` → run ID timestamp
+
+### 2. GitHub CLI Integration
+
+**Detection:**
+```bash
+which gh
+```
+
+If not found, show fallback instructions:
+```bash
+✓ Branch pushed: analytics/task-42-user-metrics
+✗ gh CLI not found - cannot create PR automatically
+
+To create PR manually:
+  gh pr create \
+    --base main \
+    --head analytics/task-42-user-metrics \
+    --title "Task #42 [analytics]: User metrics tracking" \
+    --body-file .taskmaster/reports/runs/2025-01-15-142033/pr.md
+
+Or visit:
+  https://github.com/org/repo/compare/main...analytics/task-42-user-metrics
+```
+
+**Confirmation gate:**
+```bash
+Ready to create PR:
+  Title: Task #42 [analytics]: User metrics tracking
+  Base: main
+  Head: analytics/task-42-user-metrics
+
+Create PR? [Y/n]
+```
+
+Unless `--no-confirm` flag is set.
+
+### 3. Resumable Workflow
+
+**State Checkpoint** (`state.json`):
+```json
+{
+  "runId": "2025-01-15-142033",
+  "taskId": "42",
+  "phase": "subtask-loop",
+  "currentSubtask": "42.2",
+  "currentPhase": "green",
+  "attempts": 2,
+  "completedSubtasks": ["42.1"],
+  "commits": ["a1b2c3d"],
+  "branch": "analytics/task-42-user-metrics",
+  "tag": "analytics",
+  "canResume": true,
+  "pausedAt": "2025-01-15T14:25:35Z",
+  "pausedReason": "max_attempts_reached",
+  "nextAction": "manual_review_required"
+}
+```
+
+**Resume Command:**
+```bash
+$ tm autopilot --resume
+
+Resuming run: 2025-01-15-142033
+  Task: #42 [analytics] User metrics tracking
+  Branch: analytics/task-42-user-metrics
+  Last subtask: 42.2 (GREEN phase, attempt 2/3 failed)
+  Paused: 5 minutes ago
+
+Reason: Could not achieve green state after 3 attempts
+Last error: POST /api/metrics returns 500 instead of 201
+
+Resume from subtask 42.2 GREEN phase? [Y/n]
+```
+
+**Resume logic:**
+1. Load state from `.taskmaster/reports/runs/<runId>/state.json`
+2. Verify branch still exists and is checked out
+3. Verify no uncommitted changes (unless `--force`)
+4. Continue from last checkpoint phase
+5. Update state file as execution progresses
+
+**Multiple interrupted runs:**
+```bash
+$ tm autopilot --resume
+
+Found 2 resumable runs:
+  1. 2025-01-15-142033 - Task #42 (paused 5 min ago at subtask 42.2 GREEN)
+  2. 2025-01-14-103022 - Task #38 (paused 2 hours ago at subtask 38.3 RED)
+
+Select run to resume [1-2]:
+```
+
+### 4. Coverage Enforcement
+
+**Coverage Check Phase** (before finalization):
+```typescript
+async function enforceCoverage(runId: string): Promise<void> {
+  const testResults = await testRunner.runAll()
+  const coverage = await testRunner.getCoverage()
+
+  const thresholds = config.test.coverageThresholds
+  const failures = []
+
+  if (coverage.lines < thresholds.lines) {
+    failures.push(`Lines: ${coverage.lines}% < ${thresholds.lines}%`)
+  }
+  // ... check branches, functions, statements
+
+  if (failures.length > 0) {
+    throw new CoverageError(
+      `Coverage thresholds not met:\n${failures.join('\n')}`
+    )
+  }
+
+  // Store coverage in run report
+  await storeRunArtifact(runId, 'coverage.json', coverage)
+}
+```
+
+**Handling coverage failures:**
+```bash
+⚠️  Coverage check failed:
+  Lines: 78.5% < 80%
+  Branches: 75.0% < 80%
+
+Options:
+  1. Add more tests and resume
+  2. Lower thresholds in .taskmaster/config.json
+  3. Skip coverage check: tm autopilot --resume --skip-coverage
+
+Run paused. Fix coverage and resume with:
+  tm autopilot --resume
+```
+
+### 5. Optional Lint/Format Step
+
+**Configuration:**
+```json
+{
+  "autopilot": {
+    "finalization": {
+      "lint": {
+        "enabled": true,
+        "command": "npm run lint",
+        "fix": true,
+        "failOnError": false
+      },
+      "format": {
+        "enabled": true,
+        "command": "npm run format",
+        "commitChanges": true
+      }
+    }
+  }
+}
+```
+
+**Execution:**
+```bash
+Finalization Steps:
+
+  ✓ All tests passing (12 tests, 0 failures)
+  ✓ Coverage thresholds met (85% lines, 82% branches)
+
+  LINT Running linter... ⏳
+  LINT ✓ No lint errors
+
+  FORMAT Running formatter... ⏳
+  FORMAT ✓ Formatted 3 files
+  FORMAT ✓ Committed formatting changes: "chore: auto-format code"
+
+  PUSH Pushing to origin... ⏳
+  PUSH ✓ Pushed analytics/task-42-user-metrics
+
+  PR Creating pull request... ⏳
+  PR ✓ Created PR #123
+      https://github.com/org/repo/pull/123
+```
+
+### 6. Enhanced Error Recovery
+
+**Pause Points:**
+- Max GREEN attempts reached (current)
+- Coverage check failed (new)
+- Lint errors (if `failOnError: true`)
+- Git push failed (new)
+- PR creation failed (new)
+
+**Each pause saves:**
+- Full state checkpoint
+- Last command output
+- Suggested next actions
+- Resume instructions
+
+**Automatic recovery attempts:**
+- Git push: retry up to 3 times with backoff
+- PR creation: fall back to manual instructions
+- Lint: auto-fix if enabled, otherwise pause
+
+### 7. Finalization Phase Enhancement
+
+**Updated workflow:**
+1. Run full test suite
+2. Check coverage thresholds → pause if failed
+3. Run lint (if enabled) → pause if failed and `failOnError: true`
+4. Run format (if enabled) → auto-commit changes
+5. Confirm push (unless `--no-confirm`)
+6. Push branch → retry on failure
+7. Generate PR body from template
+8. Create PR via gh → fall back to manual instructions
+9. Update task status to 'review' (configurable)
+10. Save final run report
+
+**Final output:**
+```bash
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ Task #42 [analytics]: User metrics tracking - COMPLETE
+
+  Branch: analytics/task-42-user-metrics
+  Subtasks completed: 3/3
+  Commits: 3
+  Total tests: 12 (12 passed, 0 failed)
+  Coverage: 85% lines, 82% branches, 88% functions, 85% statements
+
+  PR #123: https://github.com/org/repo/pull/123
+
+  Run report: .taskmaster/reports/runs/2025-01-15-142033/
+
+Next steps:
+  - Review PR and request changes if needed
+  - Merge when ready
+  - Task status updated to 'review'
+
+Completed in 24 minutes
+```
+
+## CLI Updates
+
+**New flags:**
+- `--resume` → Resume from last checkpoint
+- `--skip-coverage` → Skip coverage checks
+- `--skip-lint` → Skip lint step
+- `--skip-format` → Skip format step
+- `--skip-pr` → Push branch but don't create PR
+- `--draft-pr` → Create draft PR instead of ready-for-review
+
+## Configuration Updates
+
+**Add to `.taskmaster/config.json`:**
+```json
+{
+  "autopilot": {
+    "finalization": {
+      "lint": {
+        "enabled": false,
+        "command": "npm run lint",
+        "fix": true,
+        "failOnError": false
+      },
+      "format": {
+        "enabled": false,
+        "command": "npm run format",
+        "commitChanges": true
+      },
+      "updateTaskStatus": "review"
+    }
+  },
+  "git": {
+    "pr": {
+      "enabled": true,
+      "base": "default",
+      "bodyTemplate": ".taskmaster/templates/pr-body.md",
+      "draft": false
+    },
+    "pushRetries": 3,
+    "pushRetryDelay": 5000
+  }
+}
+```
+
+## Success Criteria
+- Can create PR automatically with well-formed body
+- Can resume interrupted runs from any checkpoint
+- Coverage checks prevent low-quality code from being merged
+- Clear error messages and recovery paths for all failure modes
+- Run reports include full PR context for review
+
+## Out of Scope (defer to Phase 3)
+- Multiple test framework support (pytest, go test)
+- Diff preview before commits
+- TUI panel implementation
+- Extension/IDE integration
+
+## Testing Strategy
+- Mock `gh` CLI for PR creation tests
+- Test resume from each possible pause point
+- Test coverage failure scenarios
+- Test lint/format integration with mock commands
+- End-to-end test with PR creation on test repo
+
+## Dependencies
+- Phase 1 completed (core workflow)
+- GitHub CLI (`gh`) installed (optional, fallback provided)
+- Test framework supports coverage output
+
+## Estimated Effort
+1-2 weeks
+
+## Risks & Mitigations
+- **Risk:** GitHub CLI auth issues
+  - **Mitigation:** Clear auth setup docs, fallback to manual instructions
+
+- **Risk:** PR body template doesn't match all project needs
+  - **Mitigation:** Make template customizable via config path
+
+- **Risk:** Resume state gets corrupted
+  - **Mitigation:** Validate state on load, provide --force-reset option
+
+- **Risk:** Coverage calculation differs between runs
+  - **Mitigation:** Store coverage with each test run for comparison
+
+## Validation
+Test with:
+- Successful PR creation end-to-end
+- Resume from GREEN attempt failure
+- Resume from coverage failure
+- Resume from lint failure
+- Missing `gh` CLI (fallback to manual)
+- Lint/format integration enabled
+- Multiple interrupted runs (selection UI)

.taskmaster/docs/tdd-workflow-phase-3-extensibility-guardrails.md

@@ -0,0 +1,534 @@
+# Phase 3: Extensibility + Guardrails - Autonomous TDD Workflow
+
+## Objective
+Add multi-language/framework support, enhanced safety guardrails, TUI interface, and extensibility for IDE/editor integration.
+
+## Scope
+- Multi-language test runner support (pytest, go test, etc.)
+- Enhanced safety: diff preview, confirmation gates, minimal-change prompts
+- Optional TUI panel with tmux integration
+- State-based extension API for IDE integration
+- Parallel subtask execution (experimental)
+
+## Deliverables
+
+### 1. Multi-Language Test Runner Support
+
+**Extend TestRunnerAdapter:**
+```typescript
+class TestRunnerAdapter {
+  // Existing methods...
+
+  async detectLanguage(): Promise<Language>
+  async detectFramework(language: Language): Promise<Framework>
+  async getFrameworkAdapter(framework: Framework): Promise<FrameworkAdapter>
+}
+
+enum Language {
+  JavaScript = 'javascript',
+  TypeScript = 'typescript',
+  Python = 'python',
+  Go = 'go',
+  Rust = 'rust'
+}
+
+enum Framework {
+  Vitest = 'vitest',
+  Jest = 'jest',
+  Pytest = 'pytest',
+  GoTest = 'gotest',
+  CargoTest = 'cargotest'
+}
+
+interface FrameworkAdapter {
+  runTargeted(pattern: string): Promise<TestResults>
+  runAll(): Promise<TestResults>
+  parseCoverage(output: string): Promise<CoverageReport>
+  getTestFilePattern(): string
+  getTestFileExtension(): string
+}
+```
+
+**Framework-specific adapters:**
+
+**PytestAdapter** (`packages/tm-core/src/services/test-adapters/pytest-adapter.ts`):
+```typescript
+class PytestAdapter implements FrameworkAdapter {
+  async runTargeted(pattern: string): Promise<TestResults> {
+    const output = await exec(`pytest ${pattern} --json-report`)
+    return this.parseResults(output)
+  }
+
+  async runAll(): Promise<TestResults> {
+    const output = await exec('pytest --cov --json-report')
+    return this.parseResults(output)
+  }
+
+  parseCoverage(output: string): Promise<CoverageReport> {
+    // Parse pytest-cov XML output
+  }
+
+  getTestFilePattern(): string {
+    return '**/test_*.py'
+  }
+
+  getTestFileExtension(): string {
+    return '.py'
+  }
+}
+```
+
+**GoTestAdapter** (`packages/tm-core/src/services/test-adapters/gotest-adapter.ts`):
+```typescript
+class GoTestAdapter implements FrameworkAdapter {
+  async runTargeted(pattern: string): Promise<TestResults> {
+    const output = await exec(`go test ${pattern} -json`)
+    return this.parseResults(output)
+  }
+
+  async runAll(): Promise<TestResults> {
+    const output = await exec('go test ./... -coverprofile=coverage.out -json')
+    return this.parseResults(output)
+  }
+
+  parseCoverage(output: string): Promise<CoverageReport> {
+    // Parse go test coverage output
+  }
+
+  getTestFilePattern(): string {
+    return '**/*_test.go'
+  }
+
+  getTestFileExtension(): string {
+    return '_test.go'
+  }
+}
+```
+
+**Detection Logic:**
+```typescript
+async function detectFramework(): Promise<Framework> {
+  // Check for package.json
+  if (await exists('package.json')) {
+    const pkg = await readJSON('package.json')
+    if (pkg.devDependencies?.vitest) return Framework.Vitest
+    if (pkg.devDependencies?.jest) return Framework.Jest
+  }
+
+  // Check for Python files
+  if (await exists('pytest.ini') || await exists('setup.py')) {
+    return Framework.Pytest
+  }
+
+  // Check for Go files
+  if (await exists('go.mod')) {
+    return Framework.GoTest
+  }
+
+  // Check for Rust files
+  if (await exists('Cargo.toml')) {
+    return Framework.CargoTest
+  }
+
+  throw new Error('Could not detect test framework')
+}
+```
+
+### 2. Enhanced Safety Guardrails
+
+**Diff Preview Mode:**
+```bash
+$ tm autopilot 42 --preview-diffs
+
+[2/3] Subtask 42.2: Add collection endpoint
+
+  RED   ✓ Tests created: src/api/__tests__/metrics.test.js
+
+  GREEN Implementing code...
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Proposed changes (src/api/metrics.js):
+
+  + import { MetricsSchema } from '../models/schema.js'
+  +
+  + export async function createMetric(data) {
+  +   const validated = MetricsSchema.parse(data)
+  +   const result = await db.metrics.create(validated)
+  +   return result
+  + }
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Apply these changes? [Y/n/e(dit)/s(kip)]
+  Y - Apply and continue
+  n - Reject and retry GREEN phase
+  e - Open in editor for manual changes
+  s - Skip this subtask
+```
+
+**Minimal Change Enforcement:**
+
+Add to system prompt:
+```markdown
+CRITICAL: Make MINIMAL changes to pass the failing tests.
+- Only modify files directly related to the subtask
+- Do not refactor existing code unless absolutely necessary
+- Do not add features beyond the acceptance criteria
+- Keep changes under 50 lines per file when possible
+- Prefer composition over modification
+```
+
+**Change Size Warnings:**
+```bash
+⚠️  Large change detected:
+  Files modified: 5
+  Lines changed: +234, -12
+
+This subtask was expected to be small (~50 lines).
+Consider:
+  - Breaking into smaller subtasks
+  - Reviewing acceptance criteria
+  - Checking for unintended changes
+
+Continue anyway? [y/N]
+```
+
+### 3. TUI Interface with tmux
+
+**Layout:**
+```
+┌──────────────────────────────────┬─────────────────────────────────┐
+│ Task Navigator (left)            │ Executor Terminal (right)       │
+│                                  │                                 │
+│ Project: my-app                  │ $ tm autopilot --executor-mode  │
+│ Branch: analytics/task-42        │ > Running subtask 42.2 GREEN... │
+│ Tag: analytics                   │ > Implementing endpoint...      │
+│                                  │ > Tests: 3 passed, 0 failed     │
+│ Tasks:                           │ > Ready to commit               │
+│ → 42 [in-progress] User metrics  │                                 │
+│   → 42.1 [done] Schema           │ [Live output from executor]     │
+│   → 42.2 [active] Endpoint ◀     │                                 │
+│   → 42.3 [pending] Dashboard     │                                 │
+│                                  │                                 │
+│ [s] start  [p] pause  [q] quit   │                                 │
+└──────────────────────────────────┴─────────────────────────────────┘
+```
+
+**Implementation:**
+
+**TUI Navigator** (`apps/cli/src/ui/tui/navigator.ts`):
+```typescript
+import blessed from 'blessed'
+
+class AutopilotTUI {
+  private screen: blessed.Widgets.Screen
+  private taskList: blessed.Widgets.ListElement
+  private statusBox: blessed.Widgets.BoxElement
+  private executorPane: string  // tmux pane ID
+
+  async start(taskId?: string) {
+    // Create blessed screen
+    this.screen = blessed.screen()
+
+    // Create task list widget
+    this.taskList = blessed.list({
+      label: 'Tasks',
+      keys: true,
+      vi: true,
+      style: { selected: { bg: 'blue' } }
+    })
+
+    // Spawn tmux pane for executor
+    this.executorPane = await this.spawnExecutorPane()
+
+    // Watch state file for updates
+    this.watchStateFile()
+
+    // Handle keybindings
+    this.setupKeybindings()
+  }
+
+  private async spawnExecutorPane(): Promise<string> {
+    const paneId = await exec('tmux split-window -h -P -F "#{pane_id}"')
+    await exec(`tmux send-keys -t ${paneId} "tm autopilot --executor-mode" Enter`)
+    return paneId.trim()
+  }
+
+  private watchStateFile() {
+    watch('.taskmaster/state/current-run.json', (event, filename) => {
+      this.updateDisplay()
+    })
+  }
+
+  private setupKeybindings() {
+    this.screen.key(['s'], () => this.startTask())
+    this.screen.key(['p'], () => this.pauseTask())
+    this.screen.key(['q'], () => this.quit())
+    this.screen.key(['up', 'down'], () => this.navigateTasks())
+  }
+}
+```
+
+**Executor Mode:**
+```bash
+$ tm autopilot 42 --executor-mode
+
+# Runs in executor pane, writes state to shared file
+# Left pane reads state file and updates display
+```
+
+**State File** (`.taskmaster/state/current-run.json`):
+```json
+{
+  "runId": "2025-01-15-142033",
+  "taskId": "42",
+  "status": "running",
+  "currentPhase": "green",
+  "currentSubtask": "42.2",
+  "lastOutput": "Implementing endpoint...",
+  "testsStatus": {
+    "passed": 3,
+    "failed": 0
+  }
+}
+```
+
+### 4. Extension API for IDE Integration
+
+**State-based API:**
+
+Expose run state via JSON files that IDEs can read:
+- `.taskmaster/state/current-run.json` - live run state
+- `.taskmaster/reports/runs/<runId>/manifest.json` - run metadata
+- `.taskmaster/reports/runs/<runId>/log.jsonl` - event stream
+
+**WebSocket API (optional):**
+```typescript
+// packages/tm-core/src/services/autopilot-server.ts
+class AutopilotServer {
+  private wss: WebSocketServer
+
+  start(port: number = 7890) {
+    this.wss = new WebSocketServer({ port })
+
+    this.wss.on('connection', (ws) => {
+      // Send current state
+      ws.send(JSON.stringify(this.getCurrentState()))
+
+      // Stream events
+      this.orchestrator.on('*', (event) => {
+        ws.send(JSON.stringify(event))
+      })
+    })
+  }
+}
+```
+
+**Usage from IDE extension:**
+```typescript
+// VS Code extension example
+const ws = new WebSocket('ws://localhost:7890')
+
+ws.on('message', (data) => {
+  const event = JSON.parse(data)
+
+  if (event.type === 'subtask:complete') {
+    vscode.window.showInformationMessage(
+      `Subtask ${event.subtaskId} completed`
+    )
+  }
+})
+```
+
+### 5. Parallel Subtask Execution (Experimental)
+
+**Dependency Analysis:**
+```typescript
+class SubtaskScheduler {
+  async buildDependencyGraph(subtasks: Subtask[]): Promise<DAG> {
+    const graph = new DAG()
+
+    for (const subtask of subtasks) {
+      graph.addNode(subtask.id)
+
+      for (const depId of subtask.dependencies) {
+        graph.addEdge(depId, subtask.id)
+      }
+    }
+
+    return graph
+  }
+
+  async getParallelBatches(graph: DAG): Promise<Subtask[][]> {
+    const batches: Subtask[][] = []
+    const completed = new Set<string>()
+
+    while (completed.size < graph.size()) {
+      const ready = graph.nodes.filter(node =>
+        !completed.has(node.id) &&
+        node.dependencies.every(dep => completed.has(dep))
+      )
+
+      batches.push(ready)
+      ready.forEach(node => completed.add(node.id))
+    }
+
+    return batches
+  }
+}
+```
+
+**Parallel Execution:**
+```bash
+$ tm autopilot 42 --parallel
+
+[Batch 1] Running 2 subtasks in parallel:
+  → 42.1: Add metrics schema
+  → 42.4: Add API documentation
+
+  42.1 RED   ✓ Tests created
+  42.4 RED   ✓ Tests created
+
+  42.1 GREEN ✓ Implementation complete
+  42.4 GREEN ✓ Implementation complete
+
+  42.1 COMMIT ✓ Committed: a1b2c3d
+  42.4 COMMIT ✓ Committed: e5f6g7h
+
+[Batch 2] Running 2 subtasks in parallel (depend on 42.1):
+  → 42.2: Add collection endpoint
+  → 42.3: Add dashboard widget
+  ...
+```
+
+**Conflict Detection:**
+```typescript
+async function detectConflicts(subtasks: Subtask[]): Promise<Conflict[]> {
+  const conflicts: Conflict[] = []
+
+  for (let i = 0; i < subtasks.length; i++) {
+    for (let j = i + 1; j < subtasks.length; j++) {
+      const filesA = await predictAffectedFiles(subtasks[i])
+      const filesB = await predictAffectedFiles(subtasks[j])
+
+      const overlap = filesA.filter(f => filesB.includes(f))
+
+      if (overlap.length > 0) {
+        conflicts.push({
+          subtasks: [subtasks[i].id, subtasks[j].id],
+          files: overlap
+        })
+      }
+    }
+  }
+
+  return conflicts
+}
+```
+
+### 6. Advanced Configuration
+
+**Add to `.taskmaster/config.json`:**
+```json
+{
+  "autopilot": {
+    "safety": {
+      "previewDiffs": false,
+      "maxChangeLinesPerFile": 100,
+      "warnOnLargeChanges": true,
+      "requireConfirmOnLargeChanges": true
+    },
+    "parallel": {
+      "enabled": false,
+      "maxConcurrent": 3,
+      "detectConflicts": true
+    },
+    "tui": {
+      "enabled": false,
+      "tmuxSession": "taskmaster-autopilot"
+    },
+    "api": {
+      "enabled": false,
+      "port": 7890,
+      "allowRemote": false
+    }
+  },
+  "test": {
+    "frameworks": {
+      "python": {
+        "runner": "pytest",
+        "coverageCommand": "pytest --cov",
+        "testPattern": "**/test_*.py"
+      },
+      "go": {
+        "runner": "go test",
+        "coverageCommand": "go test ./... -coverprofile=coverage.out",
+        "testPattern": "**/*_test.go"
+      }
+    }
+  }
+}
+```
+
+## CLI Updates
+
+**New commands:**
+```bash
+tm autopilot <taskId> --tui              # Launch TUI interface
+tm autopilot <taskId> --parallel         # Enable parallel execution
+tm autopilot <taskId> --preview-diffs    # Show diffs before applying
+tm autopilot <taskId> --executor-mode    # Run as executor pane
+tm autopilot-server start                # Start WebSocket API
+```
+
+## Success Criteria
+- Supports Python projects with pytest
+- Supports Go projects with go test
+- Diff preview prevents unwanted changes
+- TUI provides better visibility for long-running tasks
+- IDE extensions can integrate via state files or WebSocket
+- Parallel execution reduces total time for independent subtasks
+
+## Out of Scope
+- Full Electron/web GUI
+- AI executor selection UI (defer to Phase 4)
+- Multi-repository support
+- Remote execution on cloud runners
+
+## Testing Strategy
+- Test with Python project (pytest)
+- Test with Go project (go test)
+- Test diff preview UI with mock changes
+- Test parallel execution with independent subtasks
+- Test conflict detection with overlapping file changes
+- Test TUI with mock tmux environment
+
+## Dependencies
+- Phase 2 completed (PR + resumability)
+- tmux installed (for TUI)
+- blessed or ink library (for TUI rendering)
+
+## Estimated Effort
+3-4 weeks
+
+## Risks & Mitigations
+- **Risk:** Parallel execution causes git conflicts
+  - **Mitigation:** Conservative conflict detection, sequential fallback
+
+- **Risk:** TUI adds complexity and maintenance burden
+  - **Mitigation:** Keep TUI optional, state-based design allows alternatives
+
+- **Risk:** Framework adapters hard to maintain across versions
+  - **Mitigation:** Abstract common parsing logic, document adapter interface
+
+- **Risk:** Diff preview slows down workflow
+  - **Mitigation:** Make optional, use --preview-diffs flag only when needed
+
+## Validation
+Test with:
+- Python project with pytest and pytest-cov
+- Go project with go test
+- Large changes requiring confirmation
+- Parallel execution with 3+ independent subtasks
+- TUI with task selection and live status updates
+- VS Code extension reading state files

.taskmaster/docs/test-prd.txt

@@ -0,0 +1,8 @@
+Simple Todo App PRD
+
+Create a basic todo list application with the following features:
+1. Add new todos
+2. Mark todos as complete
+3. Delete todos
+
+That's it. Keep it simple.

.taskmaster/docs/tm-core-phase-1.txt

@@ -0,0 +1,343 @@
+# Product Requirements Document: tm-core Package - Parse PRD Feature
+
+## Project Overview
+Create a TypeScript package named `tm-core` at `packages/tm-core` that implements parse-prd functionality using class-based architecture similar to the existing AI providers pattern.
+
+## Design Patterns & Architecture
+
+### Patterns to Apply
+1. **Factory Pattern**: Use for `ProviderFactory` to create AI provider instances
+2. **Strategy Pattern**: Use for `IAIProvider` implementations and `IStorage` implementations
+3. **Facade Pattern**: Use for `TaskMasterCore` as the main API entry point
+4. **Template Method Pattern**: Use for `BaseProvider` abstract class
+5. **Dependency Injection**: Use throughout for testability (pass dependencies via constructor)
+6. **Repository Pattern**: Use for `FileStorage` to abstract data persistence
+
+### Naming Conventions
+- **Files**: kebab-case (e.g., `task-parser.ts`, `file-storage.ts`)
+- **Classes**: PascalCase (e.g., `TaskParser`, `FileStorage`)
+- **Interfaces**: PascalCase with 'I' prefix (e.g., `IStorage`, `IAIProvider`)
+- **Methods**: camelCase (e.g., `parsePRD`, `loadTasks`)
+- **Constants**: UPPER_SNAKE_CASE (e.g., `DEFAULT_MODEL`)
+- **Type aliases**: PascalCase (e.g., `TaskStatus`, `ParseOptions`)
+
+## Exact Folder Structure Required
+```
+packages/tm-core/
+├── src/
+│   ├── index.ts
+│   ├── types/
+│   │   └── index.ts
+│   ├── interfaces/
+│   │   ├── index.ts              # Barrel export
+│   │   ├── storage.interface.ts
+│   │   ├── ai-provider.interface.ts
+│   │   └── configuration.interface.ts
+│   ├── tasks/
+│   │   ├── index.ts              # Barrel export
+│   │   └── task-parser.ts
+│   ├── ai/
+│   │   ├── index.ts              # Barrel export
+│   │   ├── base-provider.ts
+│   │   ├── provider-factory.ts
+│   │   ├── prompt-builder.ts
+│   │   └── providers/
+│   │       ├── index.ts          # Barrel export
+│   │       ├── anthropic-provider.ts
+│   │       ├── openai-provider.ts
+│   │       └── google-provider.ts
+│   ├── storage/
+│   │   ├── index.ts              # Barrel export
+│   │   └── file-storage.ts
+│   ├── config/
+│   │   ├── index.ts              # Barrel export
+│   │   └── config-manager.ts
+│   ├── utils/
+│   │   ├── index.ts              # Barrel export
+│   │   └── id-generator.ts
+│   └── errors/
+│       ├── index.ts              # Barrel export
+│       └── task-master-error.ts
+├── tests/
+│   ├── task-parser.test.ts
+│   ├── integration/
+│   │   └── parse-prd.test.ts
+│   └── mocks/
+│       └── mock-provider.ts
+├── package.json
+├── tsconfig.json
+├── tsup.config.js
+└── jest.config.js
+```
+
+## Specific Implementation Requirements
+
+### 1. Create types/index.ts
+Define these exact TypeScript interfaces:
+- `Task` interface with fields: id, title, description, status, priority, complexity, dependencies, subtasks, metadata, createdAt, updatedAt, source
+- `Subtask` interface with fields: id, title, description, completed
+- `TaskMetadata` interface with fields: parsedFrom, aiProvider, version, tags (optional)
+- Type literals: `TaskStatus` = 'pending' | 'in-progress' | 'completed' | 'blocked'
+- Type literals: `TaskPriority` = 'low' | 'medium' | 'high' | 'critical'
+- Type literals: `TaskComplexity` = 'simple' | 'moderate' | 'complex'
+- `ParseOptions` interface with fields: dryRun (optional), additionalContext (optional), tag (optional), maxTasks (optional)
+
+### 2. Create interfaces/storage.interface.ts
+Define `IStorage` interface with these exact methods:
+- `loadTasks(tag?: string): Promise<Task[]>`
+- `saveTasks(tasks: Task[], tag?: string): Promise<void>`
+- `appendTasks(tasks: Task[], tag?: string): Promise<void>`
+- `updateTask(id: string, task: Partial<Task>, tag?: string): Promise<void>`
+- `deleteTask(id: string, tag?: string): Promise<void>`
+- `exists(tag?: string): Promise<boolean>`
+
+### 3. Create interfaces/ai-provider.interface.ts
+Define `IAIProvider` interface with these exact methods:
+- `generateCompletion(prompt: string, options?: AIOptions): Promise<string>`
+- `calculateTokens(text: string): number`
+- `getName(): string`
+- `getModel(): string`
+
+Define `AIOptions` interface with fields: temperature (optional), maxTokens (optional), systemPrompt (optional)
+
+### 4. Create interfaces/configuration.interface.ts
+Define `IConfiguration` interface with fields:
+- `projectPath: string`
+- `aiProvider: string`
+- `apiKey?: string`
+- `aiOptions?: AIOptions`
+- `mainModel?: string`
+- `researchModel?: string`
+- `fallbackModel?: string`
+- `tasksPath?: string`
+- `enableTags?: boolean`
+
+### 5. Create tasks/task-parser.ts
+Create class `TaskParser` with:
+- Constructor accepting `aiProvider: IAIProvider` and `config: IConfiguration`
+- Private property `promptBuilder: PromptBuilder`
+- Public method `parsePRD(prdPath: string, options: ParseOptions = {}): Promise<Task[]>`
+- Private method `readPRD(prdPath: string): Promise<string>`
+- Private method `extractTasks(aiResponse: string): Partial<Task>[]`
+- Private method `enrichTasks(rawTasks: Partial<Task>[], prdPath: string): Task[]`
+- Apply **Dependency Injection** pattern via constructor
+
+### 6. Create ai/base-provider.ts
+Copy existing base-provider.js and convert to TypeScript abstract class:
+- Abstract class `BaseProvider` implementing `IAIProvider`
+- Protected properties: `apiKey: string`, `model: string`
+- Constructor accepting `apiKey: string` and `options: { model?: string }`
+- Abstract methods matching IAIProvider interface
+- Abstract method `getDefaultModel(): string`
+- Apply **Template Method** pattern for common provider logic
+
+### 7. Create ai/provider-factory.ts
+Create class `ProviderFactory` with:
+- Static method `create(config: { provider: string; apiKey?: string; model?: string }): Promise<IAIProvider>`
+- Switch statement for providers: 'anthropic', 'openai', 'google'
+- Dynamic imports for each provider
+- Throw error for unknown providers
+- Apply **Factory** pattern for creating provider instances
+
+Example implementation structure:
+```typescript
+switch (provider.toLowerCase()) {
+  case 'anthropic':
+    const { AnthropicProvider } = await import('./providers/anthropic-provider.js');
+    return new AnthropicProvider(apiKey, { model });
+}
+```
+
+### 8. Create ai/providers/anthropic-provider.ts
+Create class `AnthropicProvider` extending `BaseProvider`:
+- Import Anthropic SDK: `import { Anthropic } from '@anthropic-ai/sdk'`
+- Private property `client: Anthropic`
+- Implement all abstract methods from BaseProvider
+- Default model: 'claude-3-sonnet-20240229'
+- Handle API errors and wrap with meaningful messages
+
+### 9. Create ai/providers/openai-provider.ts (placeholder)
+Create class `OpenAIProvider` extending `BaseProvider`:
+- Import OpenAI SDK when implemented
+- For now, throw error: "OpenAI provider not yet implemented"
+
+### 10. Create ai/providers/google-provider.ts (placeholder)
+Create class `GoogleProvider` extending `BaseProvider`:
+- Import Google Generative AI SDK when implemented
+- For now, throw error: "Google provider not yet implemented"
+
+### 11. Create ai/prompt-builder.ts
+Create class `PromptBuilder` with:
+- Method `buildParsePrompt(prdContent: string, options: ParseOptions = {}): string`
+- Method `buildExpandPrompt(task: string, context?: string): string`
+- Use template literals for prompt construction
+- Include specific JSON format instructions in prompts
+
+### 9. Create storage/file-storage.ts
+Create class `FileStorage` implementing `IStorage`:
+- Private property `basePath: string` set to `{projectPath}/.taskmaster`
+- Constructor accepting `projectPath: string`
+- Private method `getTasksPath(tag?: string): string` returning correct path based on tag
+- Private method `ensureDirectory(dir: string): Promise<void>`
+- Implement all IStorage methods
+- Handle ENOENT errors by returning empty arrays
+- Use JSON format with structure: `{ tasks: Task[], metadata: { version: string, lastModified: string } }`
+- Apply **Repository** pattern for data access abstraction
+
+### 10. Create config/config-manager.ts
+Create class `ConfigManager`:
+- Private property `config: IConfiguration`
+- Constructor accepting `options: Partial<IConfiguration>`
+- Use Zod for validation with schema matching IConfiguration
+- Method `get<K extends keyof IConfiguration>(key: K): IConfiguration[K]`
+- Method `getAll(): IConfiguration`
+- Method `validate(): boolean`
+- Default values: projectPath = process.cwd(), aiProvider = 'anthropic', enableTags = true
+
+### 11. Create utils/id-generator.ts
+Export functions:
+- `generateTaskId(index: number = 0): string` returning format `task_{timestamp}_{index}_{random}`
+- `generateSubtaskId(parentId: string, index: number = 0): string` returning format `{parentId}_sub_{index}_{random}`
+
+### 16. Create src/index.ts
+Create main class `TaskMasterCore`:
+- Private properties: `config: ConfigManager`, `storage: IStorage`, `aiProvider?: IAIProvider`, `parser?: TaskParser`
+- Constructor accepting `options: Partial<IConfiguration>`
+- Method `initialize(): Promise<void>` for lazy loading
+- Method `parsePRD(prdPath: string, options: ParseOptions = {}): Promise<Task[]>`
+- Method `getTasks(tag?: string): Promise<Task[]>`
+- Apply **Facade** pattern to provide simple API over complex subsystems
+
+Export:
+- Class `TaskMasterCore`
+- Function `createTaskMaster(options: Partial<IConfiguration>): TaskMasterCore`
+- All types from './types'
+- All interfaces from './interfaces/*'
+
+Import statements should use kebab-case:
+```typescript
+import { TaskParser } from './tasks/task-parser';
+import { FileStorage } from './storage/file-storage';
+import { ConfigManager } from './config/config-manager';
+import { ProviderFactory } from './ai/provider-factory';
+```
+
+### 17. Configure package.json
+Create package.json with:
+- name: "@task-master/core"
+- version: "0.1.0"
+- type: "module"
+- main: "./dist/index.js"
+- module: "./dist/index.mjs"
+- types: "./dist/index.d.ts"
+- exports map for proper ESM/CJS support
+- scripts: build (tsup), dev (tsup --watch), test (jest), typecheck (tsc --noEmit)
+- dependencies: zod@^3.23.8
+- peerDependencies: @anthropic-ai/sdk, openai, @google/generative-ai
+- devDependencies: typescript, tsup, jest, ts-jest, @types/node, @types/jest
+
+### 18. Configure TypeScript
+Create tsconfig.json with:
+- target: "ES2022"
+- module: "ESNext"
+- strict: true (with all strict flags enabled)
+- declaration: true
+- outDir: "./dist"
+- rootDir: "./src"
+
+### 19. Configure tsup
+Create tsup.config.js with:
+- entry: ['src/index.ts']
+- format: ['cjs', 'esm']
+- dts: true
+- sourcemap: true
+- clean: true
+- external: AI provider SDKs
+
+### 20. Configure Jest
+Create jest.config.js with:
+- preset: 'ts-jest'
+- testEnvironment: 'node'
+- Coverage threshold: 80% for all metrics
+
+## Build Process
+1. Use tsup to compile TypeScript to both CommonJS and ESM
+2. Generate .d.ts files for TypeScript consumers
+3. Output to dist/ directory
+4. Ensure tree-shaking works properly
+
+## Testing Requirements
+- Create unit tests for TaskParser in tests/task-parser.test.ts
+- Create MockProvider class in tests/mocks/mock-provider.ts for testing without API calls
+- Test error scenarios (file not found, invalid JSON, etc.)
+- Create integration test in tests/integration/parse-prd.test.ts
+- Follow kebab-case naming for all test files
+
+## Success Criteria
+- TypeScript compilation with zero errors
+- No use of 'any' type
+- All interfaces properly exported
+- Compatible with existing tasks.json format
+- Feature flag support via USE_TM_CORE environment variable
+
+## Import/Export Conventions
+- Use named exports for all classes and interfaces
+- Use barrel exports (index.ts) in each directory
+- Import types/interfaces with type-only imports: `import type { Task } from '../types'`
+- Group imports in order: Node built-ins, external packages, internal packages, relative imports
+- Use .js extension in import paths for ESM compatibility
+
+## Error Handling Patterns
+- Create custom error classes in `src/errors/` directory
+- All public methods should catch and wrap errors with context
+- Use error codes for different error types (e.g., 'FILE_NOT_FOUND', 'PARSE_ERROR')
+- Never expose internal implementation details in error messages
+- Log errors to console.error only in development mode
+
+## Barrel Exports Content
+
+### interfaces/index.ts
+```typescript
+export type { IStorage } from './storage.interface';
+export type { IAIProvider, AIOptions } from './ai-provider.interface';
+export type { IConfiguration } from './configuration.interface';
+```
+
+### tasks/index.ts
+```typescript
+export { TaskParser } from './task-parser';
+```
+
+### ai/index.ts
+```typescript
+export { BaseProvider } from './base-provider';
+export { ProviderFactory } from './provider-factory';
+export { PromptBuilder } from './prompt-builder';
+```
+
+### ai/providers/index.ts
+```typescript
+export { AnthropicProvider } from './anthropic-provider';
+export { OpenAIProvider } from './openai-provider';
+export { GoogleProvider } from './google-provider';
+```
+
+### storage/index.ts
+```typescript
+export { FileStorage } from './file-storage';
+```
+
+### config/index.ts
+```typescript
+export { ConfigManager } from './config-manager';
+```
+
+### utils/index.ts
+```typescript
+export { generateTaskId, generateSubtaskId } from './id-generator';
+```
+
+### errors/index.ts
+```typescript
+export { TaskMasterError } from './task-master-error';
+```

.taskmaster/reports/task-complexity-report.json

@@ -1,373 +1,21 @@
 {
 	"meta": {
-		"generatedAt": "2025-05-27T16:34:53.088Z",
+		"generatedAt": "2025-08-02T14:28:59.851Z",
 		"tasksAnalyzed": 1,
-		"totalTasks": 84,
-		"analysisCount": 45,
+		"totalTasks": 93,
+		"analysisCount": 1,
 		"thresholdScore": 5,
 		"projectName": "Taskmaster",
-		"usedResearch": true
+		"usedResearch": false
 	},
 	"complexityAnalysis": [
 		{
 			"taskId": 24,
 			"taskTitle": "Implement AI-Powered Test Generation Command",
-			"complexityScore": 7,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the implementation of the AI-powered test generation command into detailed subtasks covering: command structure setup, AI prompt engineering, test file generation logic, integration with Claude API, and comprehensive error handling.",
-			"reasoning": "This task involves complex integration with an AI service (Claude), requires sophisticated prompt engineering, and needs to generate structured code files. The existing 3 subtasks are a good start but could be expanded to include more detailed steps for AI integration, error handling, and test file formatting."
-		},
-		{
-			"taskId": 26,
-			"taskTitle": "Implement Context Foundation for AI Operations",
-			"complexityScore": 6,
-			"recommendedSubtasks": 4,
-			"expansionPrompt": "The current 4 subtasks for implementing the context foundation appear comprehensive. Consider if any additional subtasks are needed for testing, documentation, or integration with existing systems.",
-			"reasoning": "This task involves creating a foundation for context integration with several well-defined components. The existing 4 subtasks cover the main implementation areas (context-file flag, cursor rules integration, context extraction utility, and command handler updates). The complexity is moderate as it requires careful integration with existing systems but has clear requirements."
-		},
-		{
-			"taskId": 27,
-			"taskTitle": "Implement Context Enhancements for AI Operations",
-			"complexityScore": 7,
-			"recommendedSubtasks": 4,
-			"expansionPrompt": "The current 4 subtasks for implementing context enhancements appear well-structured. Consider if any additional subtasks are needed for testing, documentation, or performance optimization.",
-			"reasoning": "This task builds upon the foundation from Task #26 and adds more sophisticated context handling features. The 4 existing subtasks cover the main implementation areas (code context extraction, task history context, PRD context integration, and context formatting). The complexity is higher than the foundation task due to the need for intelligent context selection and optimization."
-		},
-		{
-			"taskId": 28,
-			"taskTitle": "Implement Advanced ContextManager System",
-			"complexityScore": 8,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing the advanced ContextManager system appear comprehensive. Consider if any additional subtasks are needed for testing, documentation, or backward compatibility with previous context implementations.",
-			"reasoning": "This task represents the most complex phase of the context implementation, requiring a sophisticated class design, optimization algorithms, and integration with multiple systems. The 5 existing subtasks cover the core implementation areas, but the complexity is high due to the need for intelligent context prioritization, token management, and performance monitoring."
-		},
-		{
-			"taskId": 40,
-			"taskTitle": "Implement 'plan' Command for Task Implementation Planning",
-			"complexityScore": 5,
-			"recommendedSubtasks": 4,
-			"expansionPrompt": "The current 4 subtasks for implementing the 'plan' command appear well-structured. Consider if any additional subtasks are needed for testing, documentation, or integration with existing task management workflows.",
-			"reasoning": "This task involves creating a new command that leverages AI to generate implementation plans. The existing 4 subtasks cover the main implementation areas (retrieving task content, generating plans with AI, formatting in XML, and error handling). The complexity is moderate as it builds on existing patterns for task updates but requires careful AI integration."
-		},
-		{
-			"taskId": 41,
-			"taskTitle": "Implement Visual Task Dependency Graph in Terminal",
-			"complexityScore": 8,
-			"recommendedSubtasks": 10,
-			"expansionPrompt": "The current 10 subtasks for implementing the visual task dependency graph appear comprehensive. Consider if any additional subtasks are needed for performance optimization with large graphs or additional visualization options.",
-			"reasoning": "This task involves creating a sophisticated visualization system for terminal display, which is inherently complex due to layout algorithms, ASCII/Unicode rendering, and handling complex dependency relationships. The 10 existing subtasks cover all major aspects of implementation, from CLI interface to accessibility features."
-		},
-		{
-			"taskId": 42,
-			"taskTitle": "Implement MCP-to-MCP Communication Protocol",
-			"complexityScore": 9,
-			"recommendedSubtasks": 8,
-			"expansionPrompt": "The current 8 subtasks for implementing the MCP-to-MCP communication protocol appear well-structured. Consider if any additional subtasks are needed for security hardening, performance optimization, or comprehensive documentation.",
-			"reasoning": "This task involves designing and implementing a complex communication protocol between different MCP tools and servers. It requires sophisticated adapter patterns, client-server architecture, and handling of multiple operational modes. The complexity is very high due to the need for standardization, security, and backward compatibility."
-		},
-		{
-			"taskId": 44,
-			"taskTitle": "Implement Task Automation with Webhooks and Event Triggers",
-			"complexityScore": 8,
-			"recommendedSubtasks": 7,
-			"expansionPrompt": "The current 7 subtasks for implementing task automation with webhooks appear comprehensive. Consider if any additional subtasks are needed for security testing, rate limiting implementation, or webhook monitoring tools.",
-			"reasoning": "This task involves creating a sophisticated event system with webhooks for integration with external services. The complexity is high due to the need for secure authentication, reliable delivery mechanisms, and handling of various webhook formats and protocols. The existing subtasks cover the main implementation areas but security and monitoring could be emphasized more."
-		},
-		{
-			"taskId": 45,
-			"taskTitle": "Implement GitHub Issue Import Feature",
-			"complexityScore": 6,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing the GitHub issue import feature appear well-structured. Consider if any additional subtasks are needed for handling GitHub API rate limiting, caching, or supporting additional issue metadata.",
-			"reasoning": "This task involves integrating with the GitHub API to import issues as tasks. The complexity is moderate as it requires API authentication, data mapping, and error handling. The existing 5 subtasks cover the main implementation areas from design to end-to-end implementation."
-		},
-		{
-			"taskId": 46,
-			"taskTitle": "Implement ICE Analysis Command for Task Prioritization",
-			"complexityScore": 7,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing the ICE analysis command appear comprehensive. Consider if any additional subtasks are needed for visualization of ICE scores or integration with other prioritization methods.",
-			"reasoning": "This task involves creating an AI-powered analysis system for task prioritization using the ICE methodology. The complexity is high due to the need for sophisticated scoring algorithms, AI integration, and report generation. The existing subtasks cover the main implementation areas from algorithm design to integration with existing systems."
-		},
-		{
-			"taskId": 47,
-			"taskTitle": "Enhance Task Suggestion Actions Card Workflow",
-			"complexityScore": 6,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "The current 6 subtasks for enhancing the task suggestion actions card workflow appear well-structured. Consider if any additional subtasks are needed for user testing, accessibility improvements, or performance optimization.",
-			"reasoning": "This task involves redesigning the UI workflow for task expansion and management. The complexity is moderate as it requires careful UX design and state management but builds on existing components. The 6 existing subtasks cover the main implementation areas from design to testing."
-		},
-		{
-			"taskId": 48,
-			"taskTitle": "Refactor Prompts into Centralized Structure",
-			"complexityScore": 4,
-			"recommendedSubtasks": 3,
-			"expansionPrompt": "The current 3 subtasks for refactoring prompts into a centralized structure appear appropriate. Consider if any additional subtasks are needed for prompt versioning, documentation, or testing.",
-			"reasoning": "This task involves a straightforward refactoring to improve code organization. The complexity is relatively low as it primarily involves moving code rather than creating new functionality. The 3 existing subtasks cover the main implementation areas from directory structure to integration."
-		},
-		{
-			"taskId": 49,
-			"taskTitle": "Implement Code Quality Analysis Command",
 			"complexityScore": 8,
 			"recommendedSubtasks": 6,
-			"expansionPrompt": "The current 6 subtasks for implementing the code quality analysis command appear comprehensive. Consider if any additional subtasks are needed for performance optimization with large codebases or integration with existing code quality tools.",
-			"reasoning": "This task involves creating a sophisticated code analysis system with pattern recognition, best practice verification, and AI-powered recommendations. The complexity is high due to the need for code parsing, complex analysis algorithms, and integration with AI services. The existing subtasks cover the main implementation areas from algorithm design to user interface."
-		},
-		{
-			"taskId": 50,
-			"taskTitle": "Implement Test Coverage Tracking System by Task",
-			"complexityScore": 9,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing the test coverage tracking system appear well-structured. Consider if any additional subtasks are needed for integration with CI/CD systems, performance optimization, or visualization tools.",
-			"reasoning": "This task involves creating a complex system that maps test coverage to specific tasks and subtasks. The complexity is very high due to the need for sophisticated data structures, integration with coverage tools, and AI-powered test generation. The existing subtasks are comprehensive and cover the main implementation areas from data structure design to AI integration."
-		},
-		{
-			"taskId": 51,
-			"taskTitle": "Implement Perplexity Research Command",
-			"complexityScore": 6,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing the Perplexity research command appear comprehensive. Consider if any additional subtasks are needed for caching optimization, result formatting, or integration with other research tools.",
-			"reasoning": "This task involves creating a new command that integrates with the Perplexity AI API for research. The complexity is moderate as it requires API integration, context extraction, and result formatting. The 5 existing subtasks cover the main implementation areas from API client to caching system."
-		},
-		{
-			"taskId": 52,
-			"taskTitle": "Implement Task Suggestion Command for CLI",
-			"complexityScore": 6,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing the task suggestion command appear well-structured. Consider if any additional subtasks are needed for suggestion quality evaluation, user feedback collection, or integration with existing task workflows.",
-			"reasoning": "This task involves creating a new CLI command that generates contextually relevant task suggestions using AI. The complexity is moderate as it requires AI integration, context collection, and interactive CLI interfaces. The existing subtasks cover the main implementation areas from data collection to user interface."
-		},
-		{
-			"taskId": 53,
-			"taskTitle": "Implement Subtask Suggestion Feature for Parent Tasks",
-			"complexityScore": 6,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "The current 6 subtasks for implementing the subtask suggestion feature appear comprehensive. Consider if any additional subtasks are needed for suggestion quality metrics, user feedback collection, or performance optimization.",
-			"reasoning": "This task involves creating a feature that suggests contextually relevant subtasks for parent tasks. The complexity is moderate as it builds on existing task management systems but requires sophisticated AI integration and context analysis. The 6 existing subtasks cover the main implementation areas from validation to testing."
-		},
-		{
-			"taskId": 55,
-			"taskTitle": "Implement Positional Arguments Support for CLI Commands",
-			"complexityScore": 5,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing positional arguments support appear well-structured. Consider if any additional subtasks are needed for backward compatibility testing, documentation updates, or user experience improvements.",
-			"reasoning": "This task involves modifying the command parsing logic to support positional arguments alongside the existing flag-based syntax. The complexity is moderate as it requires careful handling of different argument styles and edge cases. The 5 existing subtasks cover the main implementation areas from analysis to documentation."
-		},
-		{
-			"taskId": 57,
-			"taskTitle": "Enhance Task-Master CLI User Experience and Interface",
-			"complexityScore": 7,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "The current 6 subtasks for enhancing the CLI user experience appear comprehensive. Consider if any additional subtasks are needed for accessibility testing, internationalization, or performance optimization.",
-			"reasoning": "This task involves a significant overhaul of the CLI interface to improve user experience. The complexity is high due to the breadth of changes (logging, visual elements, interactive components, etc.) and the need for consistent design across all commands. The 6 existing subtasks cover the main implementation areas from log management to help systems."
-		},
-		{
-			"taskId": 60,
-			"taskTitle": "Implement Mentor System with Round-Table Discussion Feature",
-			"complexityScore": 8,
-			"recommendedSubtasks": 7,
-			"expansionPrompt": "The current 7 subtasks for implementing the mentor system appear well-structured. Consider if any additional subtasks are needed for mentor personality consistency, discussion quality evaluation, or performance optimization with multiple mentors.",
-			"reasoning": "This task involves creating a sophisticated mentor simulation system with round-table discussions. The complexity is high due to the need for personality simulation, complex LLM integration, and structured discussion management. The 7 existing subtasks cover the main implementation areas from architecture to testing."
-		},
-		{
-			"taskId": 62,
-			"taskTitle": "Add --simple Flag to Update Commands for Direct Text Input",
-			"complexityScore": 4,
-			"recommendedSubtasks": 8,
-			"expansionPrompt": "The current 8 subtasks for implementing the --simple flag appear comprehensive. Consider if any additional subtasks are needed for user experience testing or documentation updates.",
-			"reasoning": "This task involves adding a simple flag option to bypass AI processing for updates. The complexity is relatively low as it primarily involves modifying existing command handlers and adding a flag. The 8 existing subtasks are very detailed and cover all aspects of implementation from command parsing to testing."
-		},
-		{
-			"taskId": 63,
-			"taskTitle": "Add pnpm Support for the Taskmaster Package",
-			"complexityScore": 5,
-			"recommendedSubtasks": 8,
-			"expansionPrompt": "The current 8 subtasks for adding pnpm support appear comprehensive. Consider if any additional subtasks are needed for CI/CD integration, performance comparison, or documentation updates.",
-			"reasoning": "This task involves ensuring the package works correctly with pnpm as an alternative package manager. The complexity is moderate as it requires careful testing of installation processes and scripts across different environments. The 8 existing subtasks cover all major aspects from documentation to binary verification."
-		},
-		{
-			"taskId": 64,
-			"taskTitle": "Add Yarn Support for Taskmaster Installation",
-			"complexityScore": 5,
-			"recommendedSubtasks": 9,
-			"expansionPrompt": "The current 9 subtasks for adding Yarn support appear comprehensive. Consider if any additional subtasks are needed for performance testing, CI/CD integration, or compatibility with different Yarn versions.",
-			"reasoning": "This task involves ensuring the package works correctly with Yarn as an alternative package manager. The complexity is moderate as it requires careful testing of installation processes and scripts across different environments. The 9 existing subtasks are very detailed and cover all aspects from configuration to testing."
-		},
-		{
-			"taskId": 65,
-			"taskTitle": "Add Bun Support for Taskmaster Installation",
-			"complexityScore": 6,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "The current 6 subtasks for adding Bun support appear well-structured. Consider if any additional subtasks are needed for handling Bun-specific issues, performance testing, or documentation updates.",
-			"reasoning": "This task involves adding support for the newer Bun package manager. The complexity is slightly higher than the other package manager tasks due to Bun's differences from Node.js and potential compatibility issues. The 6 existing subtasks cover the main implementation areas from research to documentation."
-		},
-		{
-			"taskId": 67,
-			"taskTitle": "Add CLI JSON output and Cursor keybindings integration",
-			"complexityScore": 5,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing JSON output and Cursor keybindings appear well-structured. Consider if any additional subtasks are needed for testing across different operating systems, documentation updates, or user experience improvements.",
-			"reasoning": "This task involves two distinct features: adding JSON output to CLI commands and creating a keybindings installation command. The complexity is moderate as it requires careful handling of different output formats and OS-specific file paths. The 5 existing subtasks cover the main implementation areas for both features."
-		},
-		{
-			"taskId": 68,
-			"taskTitle": "Ability to create tasks without parsing PRD",
-			"complexityScore": 3,
-			"recommendedSubtasks": 2,
-			"expansionPrompt": "The current 2 subtasks for implementing task creation without PRD appear appropriate. Consider if any additional subtasks are needed for validation, error handling, or integration with existing task management workflows.",
-			"reasoning": "This task involves a relatively simple modification to allow task creation without requiring a PRD document. The complexity is low as it primarily involves creating a form interface and saving functionality. The 2 existing subtasks cover the main implementation areas of UI design and data saving."
-		},
-		{
-			"taskId": 72,
-			"taskTitle": "Implement PDF Generation for Project Progress and Dependency Overview",
-			"complexityScore": 7,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "The current 6 subtasks for implementing PDF generation appear comprehensive. Consider if any additional subtasks are needed for handling large projects, additional visualization options, or integration with existing reporting tools.",
-			"reasoning": "This task involves creating a feature to generate PDF reports of project progress and dependency visualization. The complexity is high due to the need for PDF generation, data collection, and visualization integration. The 6 existing subtasks cover the main implementation areas from library selection to export options."
-		},
-		{
-			"taskId": 75,
-			"taskTitle": "Integrate Google Search Grounding for Research Role",
-			"complexityScore": 5,
-			"recommendedSubtasks": 4,
-			"expansionPrompt": "The current 4 subtasks for integrating Google Search Grounding appear well-structured. Consider if any additional subtasks are needed for testing with different query types, error handling, or performance optimization.",
-			"reasoning": "This task involves updating the AI service layer to enable Google Search Grounding for research roles. The complexity is moderate as it requires careful integration with the existing AI service architecture and conditional logic. The 4 existing subtasks cover the main implementation areas from service layer modification to testing."
-		},
-		{
-			"taskId": 76,
-			"taskTitle": "Develop E2E Test Framework for Taskmaster MCP Server (FastMCP over stdio)",
-			"complexityScore": 8,
-			"recommendedSubtasks": 7,
-			"expansionPrompt": "The current 7 subtasks for developing the E2E test framework appear comprehensive. Consider if any additional subtasks are needed for test result reporting, CI/CD integration, or performance benchmarking.",
-			"reasoning": "This task involves creating a sophisticated end-to-end testing framework for the MCP server. The complexity is high due to the need for subprocess management, protocol handling, and robust test case definition. The 7 existing subtasks cover the main implementation areas from architecture to documentation."
-		},
-		{
-			"taskId": 77,
-			"taskTitle": "Implement AI Usage Telemetry for Taskmaster (with external analytics endpoint)",
-			"complexityScore": 7,
-			"recommendedSubtasks": 18,
-			"expansionPrompt": "The current 18 subtasks for implementing AI usage telemetry appear very comprehensive. Consider if any additional subtasks are needed for security hardening, privacy compliance, or user feedback collection.",
-			"reasoning": "This task involves creating a telemetry system to track AI usage metrics. The complexity is high due to the need for secure data transmission, comprehensive data collection, and integration across multiple commands. The 18 existing subtasks are extremely detailed and cover all aspects of implementation from core utility to provider-specific updates."
-		},
-		{
-			"taskId": 80,
-			"taskTitle": "Implement Unique User ID Generation and Storage During Installation",
-			"complexityScore": 4,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "The current 5 subtasks for implementing unique user ID generation appear well-structured. Consider if any additional subtasks are needed for privacy compliance, security auditing, or integration with the telemetry system.",
-			"reasoning": "This task involves generating and storing a unique user identifier during installation. The complexity is relatively low as it primarily involves UUID generation and configuration file management. The 5 existing subtasks cover the main implementation areas from script structure to documentation."
-		},
-		{
-			"taskId": 81,
-			"taskTitle": "Task #81: Implement Comprehensive Local Telemetry System with Future Server Integration Capability",
-			"complexityScore": 8,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "The current 6 subtasks for implementing the comprehensive local telemetry system appear well-structured. Consider if any additional subtasks are needed for data migration, storage optimization, or visualization tools.",
-			"reasoning": "This task involves expanding the telemetry system to capture additional metrics and implement local storage with future server integration capability. The complexity is high due to the breadth of data collection, storage requirements, and privacy considerations. The 6 existing subtasks cover the main implementation areas from data collection to user-facing benefits."
-		},
-		{
-			"taskId": 82,
-			"taskTitle": "Update supported-models.json with token limit fields",
-			"complexityScore": 3,
-			"recommendedSubtasks": 1,
-			"expansionPrompt": "This task appears straightforward enough to be implemented without further subtasks. Focus on researching accurate token limit values for each model and ensuring backward compatibility.",
-			"reasoning": "This task involves a simple update to the supported-models.json file to include new token limit fields. The complexity is low as it primarily involves research and data entry. No subtasks are necessary as the task is well-defined and focused."
-		},
-		{
-			"taskId": 83,
-			"taskTitle": "Update config-manager.js defaults and getters",
-			"complexityScore": 4,
-			"recommendedSubtasks": 1,
-			"expansionPrompt": "This task appears straightforward enough to be implemented without further subtasks. Focus on updating the DEFAULTS object and related getter functions while maintaining backward compatibility.",
-			"reasoning": "This task involves updating the config-manager.js module to replace maxTokens with more specific token limit fields. The complexity is relatively low as it primarily involves modifying existing code rather than creating new functionality. No subtasks are necessary as the task is well-defined and focused."
-		},
-		{
-			"taskId": 84,
-			"taskTitle": "Implement token counting utility",
-			"complexityScore": 5,
-			"recommendedSubtasks": 1,
-			"expansionPrompt": "This task appears well-defined enough to be implemented without further subtasks. Focus on implementing accurate token counting for different models and proper fallback mechanisms.",
-			"reasoning": "This task involves creating a utility function to count tokens for different AI models. The complexity is moderate as it requires integration with the tiktoken library and handling different tokenization schemes. No subtasks are necessary as the task is well-defined and focused."
-		},
-		{
-			"taskId": 69,
-			"taskTitle": "Enhance Analyze Complexity for Specific Task IDs",
-			"complexityScore": 7,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the task 'Enhance Analyze Complexity for Specific Task IDs' into 6 subtasks focusing on: 1) Core logic modification to accept ID parameters, 2) Report merging functionality, 3) CLI interface updates, 4) MCP tool integration, 5) Documentation updates, and 6) Comprehensive testing across all components.",
-			"reasoning": "This task involves modifying existing functionality across multiple components (core logic, CLI, MCP) with complex logic for filtering tasks and merging reports. The implementation requires careful handling of different parameter combinations and edge cases. The task has interdependent components that need to work together seamlessly, and the report merging functionality adds significant complexity."
-		},
-		{
-			"taskId": 70,
-			"taskTitle": "Implement 'diagram' command for Mermaid diagram generation",
-			"complexityScore": 6,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the 'diagram' command implementation into 5 subtasks: 1) Command interface and parameter handling, 2) Task data extraction and transformation to Mermaid syntax, 3) Diagram rendering with status color coding, 4) Output formatting and file export functionality, and 5) Error handling and edge case management.",
-			"reasoning": "This task requires implementing a new feature rather than modifying existing code, which reduces complexity from integration challenges. However, it involves working with visualization logic, dependency mapping, and multiple output formats. The color coding based on status and handling of dependency relationships adds moderate complexity. The task is well-defined but requires careful attention to diagram formatting and error handling."
-		},
-		{
-			"taskId": 85,
-			"taskTitle": "Update ai-services-unified.js for dynamic token limits",
-			"complexityScore": 7,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "Break down the update of ai-services-unified.js for dynamic token limits into subtasks such as: (1) Import and integrate the token counting utility, (2) Refactor _unifiedServiceRunner to calculate and enforce dynamic token limits, (3) Update error handling for token limit violations, (4) Add and verify logging for token usage, (5) Write and execute tests for various prompt and model scenarios.",
-			"reasoning": "This task involves significant code changes to a core function, integration of a new utility, dynamic logic for multiple models, and robust error handling. It also requires comprehensive testing for edge cases and integration, making it moderately complex and best managed by splitting into focused subtasks."
-		},
-		{
-			"taskId": 87,
-			"taskTitle": "Implement validation and error handling",
-			"complexityScore": 5,
-			"recommendedSubtasks": 4,
-			"expansionPrompt": "Decompose this task into: (1) Add validation logic for model and config loading, (2) Implement error handling and fallback mechanisms, (3) Enhance logging and reporting for token usage, (4) Develop helper functions for configuration suggestions and improvements.",
-			"reasoning": "This task is primarily about adding validation, error handling, and logging. While important for robustness, the logic is straightforward and can be modularized into a few clear subtasks."
-		},
-		{
-			"taskId": 89,
-			"taskTitle": "Introduce Prioritize Command with Enhanced Priority Levels",
-			"complexityScore": 6,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand this task into: (1) Implement the prioritize command with all required flags and shorthands, (2) Update CLI output and help documentation for new priority levels, (3) Ensure backward compatibility with existing commands, (4) Add error handling for invalid inputs, (5) Write and run tests for all command scenarios.",
-			"reasoning": "This CLI feature requires command parsing, updating internal logic for new priority levels, documentation, and robust error handling. The complexity is moderate due to the need for backward compatibility and comprehensive testing."
-		},
-		{
-			"taskId": 90,
-			"taskTitle": "Implement Subtask Progress Analyzer and Reporting System",
-			"complexityScore": 8,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the analyzer implementation into: (1) Design and implement progress tracking logic, (2) Develop status validation and issue detection, (3) Build the reporting system with multiple output formats, (4) Integrate analyzer with the existing task management system, (5) Optimize for performance and scalability, (6) Write unit, integration, and performance tests.",
-			"reasoning": "This is a complex, multi-faceted feature involving data analysis, reporting, integration, and performance optimization. It touches many parts of the system and requires careful design, making it one of the most complex tasks in the list."
-		},
-		{
-			"taskId": 91,
-			"taskTitle": "Implement Move Command for Tasks and Subtasks",
-			"complexityScore": 7,
-			"recommendedSubtasks": 5,
-			"expansionPrompt": "Expand this task into: (1) Implement move logic for tasks and subtasks, (2) Handle edge cases (invalid ids, non-existent parents, circular dependencies), (3) Update CLI to support move command with flags, (4) Ensure data integrity and update relationships, (5) Write and execute tests for various move scenarios.",
-			"reasoning": "Moving tasks and subtasks requires careful handling of hierarchical data, edge cases, and data integrity. The command must be robust and user-friendly, necessitating multiple focused subtasks for safe implementation."
-		},
-		{
-			"taskId": 92,
-			"taskTitle": "Add Global Joke Flag to All CLI Commands",
-			"complexityScore": 8,
-			"recommendedSubtasks": 7,
-			"expansionPrompt": "Break down the implementation of the global --joke flag into the following subtasks: (1) Update CLI foundation to support global flags, (2) Develop the joke-service module with joke management and category support, (3) Integrate joke output into existing output utilities, (4) Update all CLI commands for joke flag compatibility, (5) Add configuration options for joke categories and custom jokes, (6) Implement comprehensive testing (flag recognition, output, content, integration, performance, regression), (7) Update documentation and usage examples.",
-			"reasoning": "This task requires changes across the CLI foundation, output utilities, all command modules, and configuration management. It introduces a new service module, global flag handling, and output logic that must not interfere with existing features (including JSON output). The need for robust testing and backward compatibility further increases complexity. The scope spans multiple code areas and requires careful integration, justifying a high complexity score and a detailed subtask breakdown to manage risk and ensure maintainability.[2][3][5]"
-		},
-		{
-			"taskId": 94,
-			"taskTitle": "Implement Standalone 'research' CLI Command for AI-Powered Queries",
-			"complexityScore": 7,
-			"recommendedSubtasks": 6,
-			"expansionPrompt": "Break down the implementation of the 'research' CLI command into logical subtasks covering command registration, parameter handling, context gathering, AI service integration, output formatting, and documentation.",
-			"reasoning": "This task has moderate to high complexity (7/10) due to multiple interconnected components: CLI argument parsing, integration with AI services, context gathering from various sources, and output formatting with different modes. The cyclomatic complexity would be significant with multiple decision paths for handling different flags and options. The task requires understanding existing patterns and extending the codebase in a consistent manner, suggesting the need for careful decomposition into manageable subtasks."
-		},
-		{
-			"taskId": 86,
-			"taskTitle": "Implement GitHub Issue Export Feature",
-			"complexityScore": 9,
-			"recommendedSubtasks": 10,
-			"expansionPrompt": "Break down the implementation of the GitHub Issue Export Feature into detailed subtasks covering: command structure and CLI integration, GitHub API client development, authentication and error handling, task-to-issue mapping logic, content formatting and markdown conversion, bidirectional linking and metadata management, extensible architecture and adapter interfaces, configuration and settings management, documentation, and comprehensive testing (unit, integration, edge cases, performance).",
-			"reasoning": "This task involves designing and implementing a robust, extensible export system with deep integration into GitHub, including bidirectional workflows, complex data mapping, error handling, and support for future platforms. The requirements span CLI design, API integration, content transformation, metadata management, extensibility, configuration, and extensive testing. The breadth and depth of these requirements, along with the need for maintainability and future extensibility, place this task at a high complexity level. Breaking it into at least 10 subtasks will ensure each major component and concern is addressed systematically, reducing risk and improving quality."
+			"expansionPrompt": "Expand task 24 'Implement AI-Powered Test Generation Command' into 6 subtasks, focusing on: 1) Command structure implementation, 2) AI prompt engineering for test generation, 3) Test file generation and output, 4) Framework-specific template implementation, 5) MCP tool integration, and 6) Documentation and help system integration. Include detailed implementation steps, dependencies, and testing approaches for each subtask.",
+			"reasoning": "This task has high complexity due to several challenging aspects: 1) AI integration requiring sophisticated prompt engineering, 2) Test generation across multiple frameworks, 3) File system operations with proper error handling, 4) MCP tool integration, 5) Complex configuration requirements, and 6) Framework-specific template generation. The task already has 5 subtasks but could benefit from reorganization based on the updated implementation details in the info blocks, particularly around framework support and configuration."
 		}
 	]
 }

.taskmaster/reports/task-complexity-report_autonomous-tdd-git-workflow.json

@@ -0,0 +1,197 @@
+{
+	"meta": {
+		"generatedAt": "2025-10-07T09:46:06.248Z",
+		"tasksAnalyzed": 23,
+		"totalTasks": 23,
+		"analysisCount": 23,
+		"thresholdScore": 5,
+		"projectName": "Taskmaster",
+		"usedResearch": false
+	},
+	"complexityAnalysis": [
+		{
+			"taskId": 31,
+			"taskTitle": "Create WorkflowOrchestrator service foundation",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Break down the WorkflowOrchestrator foundation into its core architectural components: phase management system, event emitter infrastructure, state management interfaces, service integration, and lifecycle control methods. Each subtask should focus on a specific architectural concern with clear interfaces and testable units.",
+			"reasoning": "This is a foundational service requiring state machine implementation, event-driven architecture, and integration with existing services. The complexity is high due to the need for robust phase management, error handling, and service orchestration patterns."
+		},
+		{
+			"taskId": 32,
+			"taskTitle": "Implement GitAdapter for repository operations",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Decompose the GitAdapter implementation into: TypeScript wrapper creation around existing git-utils.js, core git operation methods with comprehensive error handling, branch naming pattern system with token replacement, and confirmation gates for destructive operations. Focus on type safety and existing code integration.",
+			"reasoning": "Moderate-high complexity due to TypeScript integration over existing JavaScript utilities, branch pattern implementation, and safety mechanisms. The existing git-utils.js provides a solid foundation, reducing complexity."
+		},
+		{
+			"taskId": 33,
+			"taskTitle": "Create TestRunnerAdapter for framework detection and execution",
+			"complexityScore": 8,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "Break down TestRunnerAdapter into framework detection logic, test execution engine with process management, Jest-specific result parsing, Vitest-specific result parsing, unified result interfaces, and final integration. Each framework parser should be separate to handle their unique output formats.",
+			"reasoning": "High complexity due to multiple framework support (Jest, Vitest), child process management, result parsing from different formats, coverage reporting, and timeout handling. Each framework has unique output formats requiring specialized parsers."
+		},
+		{
+			"taskId": 34,
+			"taskTitle": "Implement autopilot CLI command structure",
+			"complexityScore": 5,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Structure the autopilot command into: basic command setup with Commander.js integration, comprehensive flag handling and validation system, preflight check validation with environment validation, and WorkflowOrchestrator integration with dry-run execution planning. Follow existing CLI patterns from the codebase.",
+			"reasoning": "Moderate complexity involving CLI structure, flag handling, and integration with WorkflowOrchestrator. The existing CLI patterns and Commander.js usage in the codebase provide good guidance, reducing implementation complexity."
+		},
+		{
+			"taskId": 35,
+			"taskTitle": "Integrate surgical test generator with WorkflowOrchestrator",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Decompose the test generation integration into: TaskExecutionService enhancement for test generation mode, TestGenerationService creation using executor framework, prompt composition system for rule integration, and framework-specific test pattern support. Leverage existing executor patterns from the codebase.",
+			"reasoning": "Moderate-high complexity due to integration with existing services, prompt composition system, and framework-specific test generation. The existing executor framework and TaskExecutionService provide good integration points."
+		},
+		{
+			"taskId": 36,
+			"taskTitle": "Implement subtask TDD loop execution",
+			"complexityScore": 9,
+			"recommendedSubtasks": 7,
+			"expansionPrompt": "Break down the TDD loop into: SubtaskExecutor class architecture, RED phase test generation, GREEN phase code generation, COMMIT phase with conventional commits, retry mechanism for GREEN phase, timeout and backoff policies, and TaskService integration. Each phase should be independently testable.",
+			"reasoning": "Very high complexity due to implementing the complete TDD red-green-commit cycle with AI integration, retry logic, timeout handling, and git operations. This is the core autonomous workflow requiring robust error handling and state management."
+		},
+		{
+			"taskId": 37,
+			"taskTitle": "Add configuration schema for autopilot settings",
+			"complexityScore": 4,
+			"recommendedSubtasks": 3,
+			"expansionPrompt": "Expand configuration support into: extending configuration interfaces with autopilot settings, updating ConfigManager validation logic, and implementing default configuration values. Build on existing configuration patterns and maintain backward compatibility.",
+			"reasoning": "Low-moderate complexity involving schema extension and validation logic. The existing configuration system provides clear patterns to follow, making this primarily an extension task rather than new architecture."
+		},
+		{
+			"taskId": 38,
+			"taskTitle": "Implement run state persistence and logging",
+			"complexityScore": 6,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Structure run state management into: RunStateManager service class creation, run directory structure and manifest creation, JSONL event logging system, test result and commit tracking storage, and state checkpointing with resume functionality. Focus on data integrity and structured logging.",
+			"reasoning": "Moderate-high complexity due to file system operations, structured logging, state serialization, and resume functionality. Requires careful design of data formats and error handling for persistence operations."
+		},
+		{
+			"taskId": 39,
+			"taskTitle": "Add GitHub PR creation with run reports",
+			"complexityScore": 5,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Decompose PR creation into: PRAdapter service foundation with interfaces, GitHub CLI integration and command execution, PR body generation from run data and test results, and custom PR template system with configuration support. Leverage existing git-utils.js patterns for CLI integration.",
+			"reasoning": "Moderate complexity involving GitHub CLI integration, report generation, and template systems. The existing git-utils.js provides patterns for CLI tool integration, reducing implementation complexity."
+		},
+		{
+			"taskId": 40,
+			"taskTitle": "Implement task dependency resolution for subtask ordering",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Break down dependency resolution into: dependency resolution algorithm with cycle detection, topological sorting for subtask ordering, task eligibility checking system, and TaskService integration. Implement graph algorithms for dependency management with proper error handling.",
+			"reasoning": "Moderate-high complexity due to graph algorithm implementation, cycle detection, and integration with existing task management. Requires careful design of dependency resolution logic and edge case handling."
+		},
+		{
+			"taskId": 41,
+			"taskTitle": "Create resume functionality for interrupted runs",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Structure resume functionality into: checkpoint creation in RunStateManager, state restoration logic with validation, state validation for safe resume operations, CLI flag implementation for resume command, and partial phase resume functionality. Focus on data integrity and workflow consistency.",
+			"reasoning": "High complexity due to state serialization/deserialization, workflow restoration, validation logic, and CLI integration. Requires robust error handling and state consistency checks for reliable resume operations."
+		},
+		{
+			"taskId": 42,
+			"taskTitle": "Add coverage threshold enforcement",
+			"complexityScore": 5,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Decompose coverage enforcement into: coverage report parsing from Jest/Vitest, configurable threshold validation logic, coverage gates integration in workflow phases, and detailed coverage failure reporting system. Build on existing TestRunnerAdapter patterns.",
+			"reasoning": "Moderate complexity involving coverage report parsing, validation logic, and workflow integration. The existing TestRunnerAdapter provides good foundation for extending coverage capabilities."
+		},
+		{
+			"taskId": 43,
+			"taskTitle": "Implement tmux-based TUI navigator",
+			"complexityScore": 8,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "Break down TUI implementation into: framework selection and basic structure setup, left pane interface layout with status indicators, tmux integration and terminal coordination, navigation system with keybindings, real-time status updates system, and comprehensive event handling with UX polish. Each component should be independently testable.",
+			"reasoning": "High complexity due to terminal UI framework integration, tmux session management, real-time updates, keyboard event handling, and terminal interface design. Requires expertise in terminal UI libraries and tmux integration."
+		},
+		{
+			"taskId": 44,
+			"taskTitle": "Add prompt composition system for context-aware test generation",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Structure prompt composition into: PromptComposer service foundation, template processing engine with token replacement, rule loading system with precedence handling, and context injection with phase-specific prompt generation. Focus on flexible template system and rule management.",
+			"reasoning": "Moderate-high complexity due to template processing, rule precedence systems, and context injection logic. Requires careful design of template syntax and rule loading mechanisms."
+		},
+		{
+			"taskId": 45,
+			"taskTitle": "Implement tag-branch mapping and automatic tag switching",
+			"complexityScore": 5,
+			"recommendedSubtasks": 3,
+			"expansionPrompt": "Decompose tag-branch mapping into: GitAdapter enhancement with branch-to-tag extraction logic, automatic tag switching workflow integration, and branch-to-tag mapping persistence with validation. Build on existing git-utils.js and tag management functionality.",
+			"reasoning": "Moderate complexity involving pattern matching, tag management integration, and workflow automation. The existing git-utils.js and tag management systems provide good foundation for implementation."
+		},
+		{
+			"taskId": 46,
+			"taskTitle": "Add comprehensive error handling and recovery",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Structure error handling into: error classification system with specific error types, recovery suggestion engine with actionable recommendations, error context management and preservation, force flag implementation with selective bypass, and logging/reporting system integration. Focus on actionable error messages and automated recovery where possible.",
+			"reasoning": "High complexity due to comprehensive error taxonomy, recovery automation, context preservation, and integration across all workflow components. Requires deep understanding of failure modes and recovery strategies."
+		},
+		{
+			"taskId": 47,
+			"taskTitle": "Implement conventional commit message generation",
+			"complexityScore": 4,
+			"recommendedSubtasks": 3,
+			"expansionPrompt": "Break down commit message generation into: template system creation with variable substitution, commit type auto-detection based on task content and file changes, and validation with GitAdapter integration. Follow conventional commit standards and integrate with existing git operations.",
+			"reasoning": "Low-moderate complexity involving template processing, pattern matching for commit type detection, and validation logic. Well-defined conventional commit standards provide clear implementation guidance."
+		},
+		{
+			"taskId": 48,
+			"taskTitle": "Add multi-framework test execution support",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Expand test framework support into: framework detection system for multiple languages, common adapter interface design, Python pytest adapter implementation, Go and Rust adapter implementations, and integration with existing TestRunnerAdapter. Each language adapter should follow the unified interface pattern.",
+			"reasoning": "High complexity due to multi-language support, framework detection across different ecosystems, and adapter pattern implementation. Each language has unique testing conventions and output formats."
+		},
+		{
+			"taskId": 49,
+			"taskTitle": "Implement workflow event streaming for real-time monitoring",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Structure event streaming into: WorkflowOrchestrator EventEmitter enhancement, structured event format with metadata, event persistence to run logs, and optional WebSocket streaming for external monitoring. Focus on event consistency and real-time delivery.",
+			"reasoning": "Moderate-high complexity due to event-driven architecture, structured event formats, persistence integration, and WebSocket implementation. Requires careful design of event schemas and delivery mechanisms."
+		},
+		{
+			"taskId": 50,
+			"taskTitle": "Add intelligent test targeting for faster feedback",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Decompose test targeting into: file change detection system, test dependency analysis engine, framework-specific targeting adapters, test impact calculation algorithm, and fallback integration with TestRunnerAdapter. Focus on accuracy and performance optimization.",
+			"reasoning": "High complexity due to dependency analysis, impact calculation algorithms, framework-specific targeting, and integration with existing test execution. Requires sophisticated analysis of code relationships and test dependencies."
+		},
+		{
+			"taskId": 51,
+			"taskTitle": "Implement dry-run visualization with execution timeline",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Structure dry-run visualization into: timeline calculation engine with duration estimates, estimation algorithms based on task complexity, ASCII art progress visualization with formatting, and resource validation with preflight checks. Focus on accurate planning and clear visual presentation.",
+			"reasoning": "Moderate-high complexity due to timeline calculation, estimation algorithms, ASCII visualization, and resource validation. Requires understanding of workflow timing and visual formatting for terminal output."
+		},
+		{
+			"taskId": 52,
+			"taskTitle": "Add autopilot workflow integration tests",
+			"complexityScore": 8,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "Structure integration testing into: isolated test environment infrastructure, mock integrations and service stubs, end-to-end workflow test scenarios, performance benchmarking and resource monitoring, test isolation and parallelization strategies, and comprehensive result validation and reporting. Focus on realistic test scenarios and reliable automation.",
+			"reasoning": "High complexity due to end-to-end testing requirements, mock service integration, performance testing, isolation mechanisms, and comprehensive validation. Requires sophisticated test infrastructure and scenario design."
+		},
+		{
+			"taskId": 53,
+			"taskTitle": "Finalize autopilot documentation and examples",
+			"complexityScore": 3,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Structure documentation into: comprehensive autopilot documentation covering setup and usage, example PRD files and templates for different project types, troubleshooting guide for common issues and solutions, and demo materials with workflow visualization. Focus on clarity and practical examples.",
+			"reasoning": "Low complexity involving documentation writing, example creation, and demo material production. The main challenge is ensuring accuracy and completeness rather than technical implementation."
+		}
+	]
+}

.taskmaster/reports/task-complexity-report_tdd-phase-1-core-rails.json

@@ -0,0 +1,93 @@
+{
+	"meta": {
+		"generatedAt": "2025-10-09T12:47:27.960Z",
+		"tasksAnalyzed": 10,
+		"totalTasks": 10,
+		"analysisCount": 10,
+		"thresholdScore": 5,
+		"projectName": "Taskmaster",
+		"usedResearch": false
+	},
+	"complexityAnalysis": [
+		{
+			"taskId": 1,
+			"taskTitle": "Design and Implement Global Storage System",
+			"complexityScore": 7,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "Break down the global storage system implementation into: 1) Path normalization utilities with cross-platform support, 2) Run ID generation and validation, 3) Manifest.json structure and management, 4) Activity.jsonl append-only logging, 5) State.json mutable checkpoint handling, and 6) Directory structure creation and cleanup. Focus on robust error handling, atomic operations, and isolation between different runs.",
+			"reasoning": "Complex system requiring cross-platform path handling, multiple file formats (JSON/JSONL), atomic operations, and state management. The existing codebase shows sophisticated file operations infrastructure but this extends beyond current patterns. Implementation involves filesystem operations, concurrency concerns, and data integrity."
+		},
+		{
+			"taskId": 2,
+			"taskTitle": "Build GitAdapter with Safety Checks",
+			"complexityScore": 8,
+			"recommendedSubtasks": 7,
+			"expansionPrompt": "Decompose GitAdapter into: 1) Git repository detection and validation, 2) Working tree status checking with detailed reporting, 3) Branch operations (create, checkout, list) with safety guards, 4) Commit operations with metadata embedding, 5) Default branch detection and protection logic, 6) Push operations with conflict handling, and 7) Branch name generation from patterns. Emphasize safety checks, confirmation gates, and comprehensive error messages.",
+			"reasoning": "High complexity due to git operations safety requirements, multiple git commands integration, error handling for various git states, and safety mechanisms. The PRD emphasizes never allowing commits on default branch and requiring clean working tree - critical safety features that need robust implementation."
+		},
+		{
+			"taskId": 3,
+			"taskTitle": "Implement Test Result Validator",
+			"complexityScore": 5,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Split test validation into: 1) Input validation and schema definition for test results, 2) RED phase validation logic (ensuring failures exist), 3) GREEN phase validation logic (ensuring all tests pass), and 4) Coverage threshold validation with configurable limits. Include comprehensive validation messages and suggestions for common failure scenarios.",
+			"reasoning": "Moderate complexity focused on business logic validation. The validator is framework-agnostic (only validates reported numbers), has clear validation rules, and well-defined input/output. The existing codebase shows validation patterns that can be leveraged."
+		},
+		{
+			"taskId": 4,
+			"taskTitle": "Develop WorkflowOrchestrator State Machine",
+			"complexityScore": 9,
+			"recommendedSubtasks": 8,
+			"expansionPrompt": "Structure the orchestrator into: 1) State machine definition and transitions (Preflight → BranchSetup → SubtaskLoop → Finalize), 2) Event emission system with comprehensive event types, 3) State persistence and recovery mechanisms, 4) Phase coordination and validation, 5) Subtask iteration and progress tracking, 6) Error handling and recovery strategies, 7) Resume functionality from checkpoints, and 8) Integration points for Git, Test, and other adapters.",
+			"reasoning": "Very high complexity as the central coordination component. Must orchestrate multiple adapters, handle state transitions, event emission, persistence, and recovery. The state machine needs to be robust, resumable, and coordinate all other components. Critical for the entire workflow's reliability."
+		},
+		{
+			"taskId": 5,
+			"taskTitle": "Create Enhanced Commit Message Generator",
+			"complexityScore": 4,
+			"recommendedSubtasks": 3,
+			"expansionPrompt": "Organize commit message generation into: 1) Template parsing and variable substitution with configurable templates, 2) Scope detection from changed files with intelligent categorization, and 3) Metadata embedding (task context, test results, coverage) with conventional commits compliance. Ensure messages are parseable and contain all required task metadata.",
+			"reasoning": "Relatively straightforward text processing and template system. The conventional commits format is well-defined, and the metadata requirements are clear. The existing package.json shows commander dependency for CLI patterns that can be leveraged."
+		},
+		{
+			"taskId": 6,
+			"taskTitle": "Implement Subtask TDD Loop",
+			"complexityScore": 8,
+			"recommendedSubtasks": 6,
+			"expansionPrompt": "Break down the TDD loop into: 1) RED phase orchestration with test generation coordination, 2) GREEN phase orchestration with implementation guidance, 3) COMMIT phase with file staging and commit creation, 4) Attempt tracking and maximum retry logic, 5) Phase transition validation and state updates, and 6) Activity logging for all phase transitions. Focus on robust state management and clear error recovery paths.",
+			"reasoning": "High complexity due to coordinating multiple phases, state transitions, retry logic, and integration with multiple adapters (Git, Test, State). This is the core workflow execution engine requiring careful orchestration and error handling."
+		},
+		{
+			"taskId": 7,
+			"taskTitle": "Build CLI Commands for AI Agent Orchestration",
+			"complexityScore": 6,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Structure CLI commands into: 1) Command registration and argument parsing setup, 2) `start` and `resume` commands with initialization logic, 3) `next` and `status` commands with JSON output formatting, 4) `complete` command with result validation integration, and 5) `commit` and `abort` commands with git operation coordination. Ensure consistent JSON output for machine parsing and comprehensive error handling.",
+			"reasoning": "Moderate complexity leveraging existing CLI infrastructure. The codebase shows commander usage patterns and CLI structure. Main complexity is in JSON output formatting, argument validation, and integration with the orchestrator component."
+		},
+		{
+			"taskId": 8,
+			"taskTitle": "Develop MCP Tools for AI Agent Integration",
+			"complexityScore": 6,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Organize MCP tools into: 1) Tool schema definition and parameter validation, 2) `autopilot_start` and `autopilot_resume` tool implementation, 3) `autopilot_next` and `autopilot_status` tools with context provision, 4) `autopilot_complete_phase` tool with validation integration, and 5) `autopilot_commit` tool with git operations. Ensure parity with CLI functionality and proper error handling.",
+			"reasoning": "Moderate complexity building on existing MCP infrastructure. The codebase shows extensive MCP tooling patterns. Main work is adapting CLI functionality to MCP interface patterns and ensuring consistent behavior between CLI and MCP interfaces."
+		},
+		{
+			"taskId": 9,
+			"taskTitle": "Write AI Agent Integration Documentation and Templates",
+			"complexityScore": 2,
+			"recommendedSubtasks": 2,
+			"expansionPrompt": "Structure documentation into: 1) Comprehensive workflow documentation with step-by-step examples, command usage, and integration patterns, and 2) Template creation for CLAUDE.md integration, example prompts, and troubleshooting guides. Focus on clear examples and practical integration guidance.",
+			"reasoning": "Low complexity documentation task. Requires understanding of the implemented system but primarily involves writing clear instructions and examples. The existing codebase shows good documentation patterns that can be followed."
+		},
+		{
+			"taskId": 10,
+			"taskTitle": "Implement Configuration System and Project Hygiene",
+			"complexityScore": 5,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Structure configuration into: 1) Configuration schema definition with comprehensive validation using ajv, 2) Default configuration setup and loading mechanisms, 3) Gitignore management and project directory hygiene rules, and 4) Configuration validation and error reporting. Ensure configurations are validated on startup and provide clear error messages for invalid settings.",
+			"reasoning": "Moderate complexity involving schema validation, file operations, and configuration management. The package.json shows ajv dependency is available. Configuration systems require careful validation and user-friendly error reporting, but follow established patterns."
+		}
+	]
+}

.taskmaster/reports/task-complexity-report_tdd-workflow-phase-0.json

@@ -0,0 +1,93 @@
+{
+	"meta": {
+		"generatedAt": "2025-10-07T14:16:40.283Z",
+		"tasksAnalyzed": 10,
+		"totalTasks": 10,
+		"analysisCount": 10,
+		"thresholdScore": 5,
+		"projectName": "Taskmaster",
+		"usedResearch": false
+	},
+	"complexityAnalysis": [
+		{
+			"taskId": 1,
+			"taskTitle": "Create autopilot command CLI skeleton",
+			"complexityScore": 4,
+			"recommendedSubtasks": 3,
+			"expansionPrompt": "Break down the autopilot command creation into: 1) Create AutopilotCommand class extending Commander.Command with proper argument parsing and options, 2) Implement command structure with help text and validation following existing patterns, 3) Add basic registration method and placeholder action handler",
+			"reasoning": "Medium complexity due to following established patterns in the codebase. The command-registry.ts and start.command.ts provide clear templates for implementation. Main complexity is argument parsing and option validation."
+		},
+		{
+			"taskId": 2,
+			"taskTitle": "Implement preflight detection system",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Create PreflightChecker with these subtasks: 1) Package.json test script detection and validation, 2) Git working tree status checking using system commands, 3) Tool availability validation (git, gh, node/npm), 4) Default branch detection via git commands, 5) Structured result reporting with success/failure indicators and error messages",
+			"reasoning": "High complexity due to system integration requirements. Needs to interact with multiple external tools (git, npm, gh), parse various file formats, and handle different system configurations. Error handling for missing tools adds complexity."
+		},
+		{
+			"taskId": 3,
+			"taskTitle": "Implement task loading and validation",
+			"complexityScore": 5,
+			"recommendedSubtasks": 3,
+			"expansionPrompt": "Implement task loading: 1) Use existing TaskService from @tm/core to load tasks by ID with proper error handling, 2) Validate task structure including subtask existence and dependency validation, 3) Provide user-friendly error messages for missing tasks or need to expand subtasks first",
+			"reasoning": "Medium-high complexity. While leveraging existing TaskService reduces implementation effort, the validation logic for subtasks and dependencies requires careful handling of edge cases. Task structure validation adds complexity."
+		},
+		{
+			"taskId": 4,
+			"taskTitle": "Create execution plan display logic",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Build ExecutionPlanDisplay: 1) Create display formatter using boxen and chalk for consistent CLI styling, 2) Format preflight check results with color-coded status indicators, 3) Display subtask execution order with RED/GREEN/COMMIT phase visualization, 4) Show branch/tag info and finalization steps with duration estimates",
+			"reasoning": "Moderate-high complexity due to complex formatting requirements and dependency on multiple other components. The display needs to coordinate information from preflight, task validation, and execution planning. CLI styling consistency adds complexity."
+		},
+		{
+			"taskId": 5,
+			"taskTitle": "Implement branch and tag planning",
+			"complexityScore": 3,
+			"recommendedSubtasks": 2,
+			"expansionPrompt": "Create BranchPlanner: 1) Implement branch name generation using pattern <tag>/task-<id>-<slug> with kebab-case conversion and special character handling, 2) Add TaskMaster config integration to determine active tag and handle existing branch conflicts",
+			"reasoning": "Low-medium complexity. String manipulation and naming convention implementation is straightforward. The main complexity is handling edge cases with special characters and existing branch conflicts."
+		},
+		{
+			"taskId": 6,
+			"taskTitle": "Create subtask execution order calculation",
+			"complexityScore": 8,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Implement dependency resolution: 1) Build dependency graph from subtask data with proper parsing, 2) Implement topological sort algorithm for execution order, 3) Add circular dependency detection with clear error reporting, 4) Create parallel execution grouping for independent subtasks",
+			"reasoning": "High complexity due to graph algorithms and dependency resolution. Topological sorting, circular dependency detection, and parallel grouping require algorithmic sophistication. Edge cases in dependency chains add significant complexity."
+		},
+		{
+			"taskId": 7,
+			"taskTitle": "Implement TDD phase planning for subtasks",
+			"complexityScore": 6,
+			"recommendedSubtasks": 4,
+			"expansionPrompt": "Create TDDPhasePlanner: 1) Implement test file path detection for common project structures (src/, tests/, __tests__), 2) Parse implementation files from subtask details and descriptions, 3) Generate conventional commit messages for RED/GREEN/COMMIT phases, 4) Add implementation complexity estimation based on subtask content",
+			"reasoning": "Moderate-high complexity due to project structure detection and file path inference. Conventional commit message generation and complexity estimation require understanding of different project layouts and parsing subtask content effectively."
+		},
+		{
+			"taskId": 8,
+			"taskTitle": "Add finalization steps planning",
+			"complexityScore": 4,
+			"recommendedSubtasks": 3,
+			"expansionPrompt": "Create FinalizationPlanner: 1) Implement test suite execution planning with coverage threshold detection from package.json, 2) Add git operations planning (branch push, PR creation) using existing git patterns, 3) Create duration estimation algorithm based on subtask count and complexity metrics",
+			"reasoning": "Medium complexity. Building on existing git utilities and test command detection reduces complexity. Main challenges are coverage threshold parsing and duration estimation algorithms."
+		},
+		{
+			"taskId": 9,
+			"taskTitle": "Integrate command with existing CLI infrastructure",
+			"complexityScore": 3,
+			"recommendedSubtasks": 2,
+			"expansionPrompt": "Complete CLI integration: 1) Add AutopilotCommand to command-registry.ts following existing patterns and update command metadata, 2) Test command registration and help system integration with proper cleanup and error handling",
+			"reasoning": "Low-medium complexity. The command-registry.ts provides a clear pattern to follow. Main work is registration and ensuring proper integration with existing CLI infrastructure. Well-established patterns reduce complexity."
+		},
+		{
+			"taskId": 10,
+			"taskTitle": "Add comprehensive error handling and edge cases",
+			"complexityScore": 7,
+			"recommendedSubtasks": 5,
+			"expansionPrompt": "Implement error handling: 1) Add missing task and invalid task structure error handling with helpful messages, 2) Handle git state errors (dirty working tree, missing tools), 3) Add dependency validation errors (circular, invalid references), 4) Implement missing tool detection with installation guidance, 5) Create user-friendly error messages following existing CLI patterns",
+			"reasoning": "High complexity due to comprehensive error scenarios. Each component (preflight, task loading, dependency resolution) has multiple failure modes that need proper handling. Providing helpful error messages and recovery suggestions adds complexity."
+		}
+	]
+}

.taskmaster/reports/task-complexity-report_tm-core-phase-1.json

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

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

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

.taskmaster/state.json

@@ -1,6 +1,6 @@
 {
-	"currentTag": "master",
-	"lastSwitched": "2025-07-22T13:32:03.558Z",
+	"currentTag": "tdd-phase-1-core-rails",
+	"lastSwitched": "2025-10-09T12:41:40.367Z",
 	"branchTagMapping": {
 		"v017-adds": "v017-adds",
 		"next": "next"

.taskmaster/tasks/task_001_tm-start.txt

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

.taskmaster/tasks/task_002_tm-start.txt

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

.taskmaster/tasks/task_003_tm-start.txt

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

.taskmaster/tasks/task_004_tm-start.txt

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

.taskmaster/tasks/task_007_tm-start.txt

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

.taskmaster/templates/example_prd_rpg.txt

@@ -0,0 +1,511 @@
+<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>

.vscode/settings.json

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

CLAUDE.md

@@ -3,3 +3,41 @@
 ## Task Master AI Instructions
 **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
+
+### Test File Placement
+
+- **Package & tests**: Place in `packages/<package-name>/src/<module>/<file>.spec.ts` or `apps/<app-name>/src/<module>/<file.spec.ts>` alongside source
+- **Package integration tests**: Place in `packages/<package-name>/tests/integration/<module>/<file>.test.ts` or `apps/<app-name>/tests/integration/<module>/<file>.test.ts` alongside source
+- **Isolated unit tests**: Use `tests/unit/packages/<package-name>/` only when parallel placement isn't possible
+- **Test extension**: Always use `.ts` for TypeScript tests, never `.js`
+
+### 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:
+  ```typescript
+  // ✅ CORRECT - Synchronous imports with .ts extension
+  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);
+  });
+  ```
+
+## Documentation Guidelines
+
+- **Documentation location**: Write docs in `apps/docs/` (Mintlify site source), not `docs/`
+- **Documentation URL**: Reference docs at https://docs.task-master.dev, not local file paths
+
+## 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

@@ -0,0 +1,140 @@
+# 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

@@ -1,14 +1,39 @@
-# Task Master [![GitHub stars](https://img.shields.io/github/stars/eyaltoledano/claude-task-master?style=social)](https://github.com/eyaltoledano/claude-task-master/stargazers)
+<a name="readme-top"></a>
 
-[![CI](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml/badge.svg)](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml) [![npm version](https://badge.fury.io/js/task-master-ai.svg)](https://badge.fury.io/js/task-master-ai) [![Discord](https://dcbadge.limes.pink/api/server/https://discord.gg/taskmasterai?style=flat)](https://discord.gg/taskmasterai) [![License: MIT with Commons Clause](https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg)](LICENSE)
+<div align='center'>
+<a href="https://trendshift.io/repositories/13971" target="_blank"><img src="https://trendshift.io/api/badge/repositories/13971" alt="eyaltoledano%2Fclaude-task-master | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+</div>
 
-[![NPM Downloads](https://img.shields.io/npm/d18m/task-master-ai?style=flat)](https://www.npmjs.com/package/task-master-ai) [![NPM Downloads](https://img.shields.io/npm/dm/task-master-ai?style=flat)](https://www.npmjs.com/package/task-master-ai) [![NPM Downloads](https://img.shields.io/npm/dw/task-master-ai?style=flat)](https://www.npmjs.com/package/task-master-ai)
+<p align="center">
+  <a href="https://task-master.dev"><img src="./images/logo.png?raw=true" alt="Taskmaster logo"></a>
+</p>
 
-## By [@eyaltoledano](https://x.com/eyaltoledano), [@RalphEcom](https://x.com/RalphEcom) & [@jasonzhou1993](https://x.com/jasonzhou1993)
+<p align="center">
+<b>Taskmaster</b>: A task management system for AI-driven development, designed to work seamlessly with any AI chat.
+</p>
+
+<p align="center">
+  <a href="https://discord.gg/taskmasterai" target="_blank"><img src="https://dcbadge.limes.pink/api/server/https://discord.gg/taskmasterai?style=flat" alt="Discord"></a> |
+  <a href="https://docs.task-master.dev" target="_blank">Docs</a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml"><img src="https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://github.com/eyaltoledano/claude-task-master/stargazers"><img src="https://img.shields.io/github/stars/eyaltoledano/claude-task-master?style=social" alt="GitHub stars"></a>
+  <a href="https://badge.fury.io/js/task-master-ai"><img src="https://badge.fury.io/js/task-master-ai.svg" alt="npm version"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg" alt="License"></a>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/task-master-ai"><img src="https://img.shields.io/npm/d18m/task-master-ai?style=flat" alt="NPM Downloads"></a>
+  <a href="https://www.npmjs.com/package/task-master-ai"><img src="https://img.shields.io/npm/dm/task-master-ai?style=flat" alt="NPM Downloads"></a>
+  <a href="https://www.npmjs.com/package/task-master-ai"><img src="https://img.shields.io/npm/dw/task-master-ai?style=flat" alt="NPM Downloads"></a>
+</p>
+
+## By [@eyaltoledano](https://x.com/eyaltoledano) & [@RalphEcom](https://x.com/RalphEcom)
 
 [![Twitter Follow](https://img.shields.io/twitter/follow/eyaltoledano)](https://x.com/eyaltoledano)
 [![Twitter Follow](https://img.shields.io/twitter/follow/RalphEcom)](https://x.com/RalphEcom)
-[![Twitter Follow](https://img.shields.io/twitter/follow/jasonzhou1993)](https://x.com/jasonzhou1993)
 
 A task management system for AI-driven development with Claude, designed to work seamlessly with Cursor AI.
 
@@ -31,10 +56,23 @@ The following documentation is also available in the `docs` directory:
 
 #### Quick Install for Cursor 1.0+ (One-Click)
 
-[![Add task-master-ai MCP server to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=task-master-ai&config=eyJjb21tYW5kIjoibnB4IC15IC0tcGFja2FnZT10YXNrLW1hc3Rlci1haSB0YXNrLW1hc3Rlci1haSIsImVudiI6eyJBTlRIUk9QSUNfQVBJX0tFWSI6IllPVVJfQU5USFJPUElDX0FQSV9LRVlfSEVSRSIsIlBFUlBMRVhJVFlfQVBJX0tFWSI6IllPVVJfUEVSUExFWElUWV9BUElfS0VZX0hFUkUiLCJPUEVOQUlfQVBJX0tFWSI6IllPVVJfT1BFTkFJX0tFWV9IRVJFIiwiR09PR0xFX0FQSV9LRVkiOiJZT1VSX0dPT0dMRV9LRVlfSEVSRSIsIk1JU1RSQUxfQVBJX0tFWSI6IllPVVJfTUlTVFJBTF9LRVlfSEVSRSIsIkdST1FfQVBJX0tFWSI6IllPVVJfR1JPUV9LRVlfSEVSRSIsIk9QRU5ST1VURVJfQVBJX0tFWSI6IllPVVJfT1BFTlJPVVRFUl9LRVlfSEVSRSIsIlhBSV9BUElfS0VZIjoiWU9VUl9YQUlfS0VZX0hFUkUiLCJBWlVSRV9PUEVOQUlfQVBJX0tFWSI6IllPVVJfQVpVUkVfS0VZX0hFUkUiLCJPTExBTUFfQVBJX0tFWSI6IllPVVJfT0xMQU1BX0FQSV9LRVlfSEVSRSJ9fQ%3D%3D)
+[![Add task-master-ai MCP server to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=task-master-ai&config=eyJjb21tYW5kIjoibnB4IC15IC0tcGFja2FnZT10YXNrLW1hc3Rlci1haSB0YXNrLW1hc3Rlci1haSIsImVudiI6eyJBTlRIUk9QSUNfQVBJX0tFWSI6IllPVVJfQU5USFJPUElDX0FQSV9LRVlfSEVSRSIsIlBFUlBMRVhJVFlfQVBJX0tFWSI6IllPVVJfUEVSUExFWElUWV9BUElfS0VZX0hFUkUiLCJPUEVOQUlfQVBJX0tFWSI6IllPVVJfT1BFTkFJX0tFWV9IRVJFIiwiR09PR0xFX0FQSV9LRVkiOiJZT1VSX0dPT0dMRV9LRVlfSEVSRSIsIk1JU1RSQUxfQVBJX0tFWSI6IllPVVJfTUlTVFJBTF9LRVlfSEVSRSIsIkdST1FfQVBJX0tFWSI6IllPVVJfR1JPUV9LRVlfSEVSRSIsIk9QRU5ST1VURVJfQVBJX0tFWSI6IllPVVJfT1BFTlJPVVRFUl9LRVlfSEVSRSIsIlhBSV9BUElfS0VZIjoiWU9VUl9YQUlfS0VZX0hFUkUiLCJBWlVSRV9PUEVOQUlfQVBJX0tFWSI6IllPVVJfQVpVUkVfS0VZX0hFUkUiLCJPTExBTUFfQVBJX0tFWSI6IllPVVJfT0xMQU1BX0FQSV9LRVlfSEVSRSJ9fQ%3D%3D)
 
 > **Note:** After clicking the link, you'll still need to add your API keys to the configuration. The link installs the MCP server with placeholder keys that you'll need to replace with your actual API keys.
 
+#### Claude Code Quick Install
+
+For Claude Code users:
+
+```bash
+claude mcp add taskmaster-ai -- npx -y task-master-ai
+```
+
+Don't forget to add your API keys to the configuration:
+- in the root .env of your Project
+- in the "env" section of your mcp config for taskmaster-ai
+
+
 ## Requirements
 
 Taskmaster utilizes AI across several commands, and those require a separate API key. You can use a variety of models from different AI providers provided you add your API keys. For example, if you want to use Claude 3.7, you'll need an Anthropic API key.
@@ -50,8 +88,9 @@ 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). 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 or Codex CLI with OAuth). Adding all API keys enables you to seamlessly switch between model providers at will.
 
 ## Quick Start
 
@@ -67,18 +106,20 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
 |              | Project | `<project_folder>/.cursor/mcp.json`   | `<project_folder>\.cursor\mcp.json`               | `mcpServers` |
 | **Windsurf** | Global  | `~/.codeium/windsurf/mcp_config.json` | `%USERPROFILE%\.codeium\windsurf\mcp_config.json` | `mcpServers` |
 | **VS Code**  | Project | `<project_folder>/.vscode/mcp.json`   | `<project_folder>\.vscode\mcp.json`               | `servers`    |
+| **Q CLI**    | Global  | `~/.aws/amazonq/mcp.json`             |                                                   | `mcpServers` |
 
 ##### Manual Configuration
 
-###### Cursor & Windsurf (`mcpServers`)
+###### Cursor & Windsurf & Q Developer CLI (`mcpServers`)
 
 ```json
 {
   "mcpServers": {
     "task-master-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
+        // "TASK_MASTER_TOOLS": "all", // Options: "all", "standard", "core", or comma-separated list of tools
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
         "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
@@ -97,7 +138,7 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
 
 > 🔑 Replace `YOUR_…_KEY_HERE` with your real API keys. You can remove keys you don't use.
 
-> **Note**: If you see `0 tools enabled` in the MCP settings, try removing the `--package=task-master-ai` flag from `args`.
+> **Note**: If you see `0 tools enabled` in the MCP settings, restart your editor and check that your API keys are correctly configured.
 
 ###### VS Code (`servers` + `type`)
 
@@ -106,8 +147,9 @@ MCP (Model Control Protocol) lets you run Task Master directly from your editor.
   "servers": {
     "task-master-ai": {
       "command": "npx",
-      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "args": ["-y", "task-master-ai"],
       "env": {
+        // "TASK_MASTER_TOOLS": "all", // Options: "all", "standard", "core", or comma-separated list of tools
         "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
         "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
         "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
@@ -156,7 +198,7 @@ Initialize taskmaster-ai in my project
 
 #### 5. Make sure you have a PRD (Recommended)
 
-For **new projects**: Create your PRD at `.taskmaster/docs/prd.txt`  
+For **new projects**: Create your PRD at `.taskmaster/docs/prd.txt`.
 For **existing projects**: You can use `scripts/prd.txt` or migrate with `task-master migrate`
 
 An example PRD template is available after initialization in `.taskmaster/templates/example_prd.txt`.
@@ -230,6 +272,11 @@ task-master show 1,3,5
 # Research fresh information with project context
 task-master research "What are the latest best practices for JWT authentication?"
 
+# Move tasks between tags (cross-tag movement)
+task-master move --from=5 --from-tag=backlog --to-tag=in-progress
+task-master move --from=5,6,7 --from-tag=backlog --to-tag=done --with-dependencies
+task-master move --from=5 --from-tag=backlog --to-tag=in-progress --ignore-dependencies
+
 # Generate task files
 task-master generate
 
@@ -237,6 +284,76 @@ task-master generate
 task-master rules add windsurf,roo,vscode
 ```
 
+## Tool Loading Configuration
+
+### Optimizing MCP Tool Loading
+
+Task Master's MCP server supports selective tool loading to reduce context window usage. By default, all 36 tools are loaded (~21,000 tokens) to maintain backward compatibility with existing installations.
+
+You can optimize performance by configuring the `TASK_MASTER_TOOLS` environment variable:
+
+### Available Modes
+
+| Mode | Tools | Context Usage | Use Case |
+|------|-------|--------------|----------|
+| `all` (default) | 36 | ~21,000 tokens | Complete feature set - all tools available |
+| `standard` | 15 | ~10,000 tokens | Common task management operations |
+| `core` (or `lean`) | 7 | ~5,000 tokens | Essential daily development workflow |
+| `custom` | Variable | Variable | Comma-separated list of specific tools |
+
+### Configuration Methods
+
+#### Method 1: Environment Variable in MCP Configuration
+
+Add `TASK_MASTER_TOOLS` to your MCP configuration file's `env` section:
+
+```jsonc
+{
+  "mcpServers": {  // or "servers" for VS Code
+    "task-master-ai": {
+      "command": "npx",
+      "args": ["-y", "--package=task-master-ai", "task-master-ai"],
+      "env": {
+        "TASK_MASTER_TOOLS": "standard",  // Options: "all", "standard", "core", "lean", or comma-separated list
+        "ANTHROPIC_API_KEY": "your-key-here",
+        // ... other API keys
+      }
+    }
+  }
+}
+```
+
+#### Method 2: Claude Code CLI (One-Time Setup)
+
+For Claude Code users, you can set the mode during installation:
+
+```bash
+# Core mode example (~70% token reduction)
+claude mcp add task-master-ai --scope user \
+  --env TASK_MASTER_TOOLS="core" \
+  -- npx -y task-master-ai@latest
+
+# Custom tools example
+claude mcp add task-master-ai --scope user \
+  --env TASK_MASTER_TOOLS="get_tasks,next_task,set_task_status" \
+  -- npx -y task-master-ai@latest
+```
+
+### Tool Sets Details
+
+**Core Tools (7):** `get_tasks`, `next_task`, `get_task`, `set_task_status`, `update_subtask`, `parse_prd`, `expand_task`
+
+**Standard Tools (15):** All core tools plus `initialize_project`, `analyze_project_complexity`, `expand_all`, `add_subtask`, `remove_task`, `generate`, `add_task`, `complexity_report`
+
+**All Tools (36):** Complete set including project setup, task management, analysis, dependencies, tags, research, and more
+
+### Recommendations
+
+- **New users**: Start with `"standard"` mode for a good balance
+- **Large projects**: Use `"core"` mode to minimize token usage
+- **Complex workflows**: Use `"all"` mode or custom selection
+- **Backward compatibility**: If not specified, defaults to `"all"` mode
+
 ## Claude Code Support
 
 Task Master now supports Claude models through the Claude Code CLI, which requires no API key:
@@ -265,6 +382,12 @@ 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

@@ -0,0 +1,41 @@
+# @tm/cli
+
+## null
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tm/core@null
+
+## null
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tm/core@null
+
+## null
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tm/core@null
+
+## 0.27.0
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @tm/core@0.26.1
+
+## 0.27.0-rc.0
+
+### Minor Changes
+
+- [#1213](https://github.com/eyaltoledano/claude-task-master/pull/1213) [`137ef36`](https://github.com/eyaltoledano/claude-task-master/commit/137ef362789a9cdfdb1925e35e0438c1fa6c69ee) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - testing this stuff out to see how the release candidate works with monorepo
+
+## 1.1.0-rc.0
+
+### Minor Changes
+
+- [#1213](https://github.com/eyaltoledano/claude-task-master/pull/1213) [`cd90b4d`](https://github.com/eyaltoledano/claude-task-master/commit/cd90b4d65fc2f04bdad9fb73aba320b58a124240) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - testing this stuff out to see how the release candidate works with monorepo

apps/cli/package.json

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

apps/cli/src/command-registry.ts

@@ -0,0 +1,270 @@
+/**
+ * @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 { NextCommand } from './commands/next.command.js';
+import { AuthCommand } from './commands/auth.command.js';
+import { ContextCommand } from './commands/context.command.js';
+import { StartCommand } from './commands/start.command.js';
+import { SetStatusCommand } from './commands/set-status.command.js';
+import { ExportCommand } from './commands/export.command.js';
+import { AutopilotCommand } from './commands/autopilot/index.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: 'next',
+			description: 'Find the next available task to work on',
+			commandClass: NextCommand as any,
+			category: 'task'
+		},
+		{
+			name: 'start',
+			description: 'Start working on a task with claude-code',
+			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'
+		},
+		{
+			name: 'autopilot',
+			description:
+				'AI agent orchestration for TDD workflow (start, resume, next, complete, commit, status, abort)',
+			commandClass: AutopilotCommand as any,
+			category: 'development'
+		},
+
+		// 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

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

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

@@ -0,0 +1,515 @@
+/**
+ * @fileoverview AutopilotCommand using Commander's native class pattern
+ * Extends Commander.Command for better integration with the framework
+ * This is a thin presentation layer over @tm/core's autopilot functionality
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import ora, { type Ora } from 'ora';
+import {
+	createTaskMasterCore,
+	type TaskMasterCore,
+	type Task,
+	type Subtask
+} from '@tm/core';
+import * as ui from '../utils/ui.js';
+
+/**
+ * CLI-specific options interface for the autopilot command
+ */
+export interface AutopilotCommandOptions {
+	format?: 'text' | 'json';
+	project?: string;
+	dryRun?: boolean;
+}
+
+/**
+ * Preflight check result for a single check
+ */
+export interface PreflightCheckResult {
+	success: boolean;
+	message?: string;
+}
+
+/**
+ * Overall preflight check results
+ */
+export interface PreflightResult {
+	success: boolean;
+	testCommand: PreflightCheckResult;
+	gitWorkingTree: PreflightCheckResult;
+	requiredTools: PreflightCheckResult;
+	defaultBranch: PreflightCheckResult;
+}
+
+/**
+ * CLI-specific result type from autopilot command
+ */
+export interface AutopilotCommandResult {
+	success: boolean;
+	taskId: string;
+	task?: Task;
+	error?: string;
+	message?: string;
+}
+
+/**
+ * AutopilotCommand extending Commander's Command class
+ * This is a thin presentation layer over @tm/core's autopilot functionality
+ */
+export class AutopilotCommand extends Command {
+	private tmCore?: TaskMasterCore;
+	private lastResult?: AutopilotCommandResult;
+
+	constructor(name?: string) {
+		super(name || 'autopilot');
+
+		// Configure the command
+		this.description(
+			'Execute a task autonomously using TDD workflow with git integration'
+		)
+			.argument('<taskId>', 'Task ID to execute autonomously')
+			.option('-f, --format <format>', 'Output format (text, json)', 'text')
+			.option('-p, --project <path>', 'Project root directory', process.cwd())
+			.option(
+				'--dry-run',
+				'Show what would be executed without performing actions'
+			)
+			.action(async (taskId: string, options: AutopilotCommandOptions) => {
+				await this.executeCommand(taskId, options);
+			});
+	}
+
+	/**
+	 * Execute the autopilot command
+	 */
+	private async executeCommand(
+		taskId: string,
+		options: AutopilotCommandOptions
+	): Promise<void> {
+		let spinner: Ora | null = null;
+
+		try {
+			// Validate options
+			if (!this.validateOptions(options)) {
+				process.exit(1);
+			}
+
+			// Validate task ID format
+			if (!this.validateTaskId(taskId)) {
+				ui.displayError(`Invalid task ID format: ${taskId}`);
+				process.exit(1);
+			}
+
+			// Initialize tm-core with spinner
+			spinner = ora('Initializing Task Master...').start();
+			await this.initializeCore(options.project || process.cwd());
+			spinner.succeed('Task Master initialized');
+
+			// Load and validate task existence
+			spinner = ora(`Loading task ${taskId}...`).start();
+			const task = await this.loadTask(taskId);
+
+			if (!task) {
+				spinner.fail(`Task ${taskId} not found`);
+				ui.displayError(`Task with ID ${taskId} does not exist`);
+				process.exit(1);
+			}
+
+			spinner.succeed(`Task ${taskId} loaded`);
+
+			// Display task information
+			this.displayTaskInfo(task, options.dryRun || false);
+
+			// Execute autopilot logic (placeholder for now)
+			const result = await this.performAutopilot(taskId, task, options);
+
+			// Store result for programmatic access
+			this.setLastResult(result);
+
+			// Display results
+			this.displayResults(result, options);
+		} catch (error: unknown) {
+			if (spinner) {
+				spinner.fail('Operation failed');
+			}
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Validate command options
+	 */
+	private validateOptions(options: AutopilotCommandOptions): boolean {
+		// Validate format
+		if (options.format && !['text', 'json'].includes(options.format)) {
+			console.error(chalk.red(`Invalid format: ${options.format}`));
+			console.error(chalk.gray(`Valid formats: text, json`));
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Validate task ID format
+	 */
+	private validateTaskId(taskId: string): boolean {
+		// Task ID should be a number or number.number format (e.g., "1" or "1.2")
+		const taskIdPattern = /^\d+(\.\d+)*$/;
+		return taskIdPattern.test(taskId);
+	}
+
+	/**
+	 * Initialize TaskMasterCore
+	 */
+	private async initializeCore(projectRoot: string): Promise<void> {
+		if (!this.tmCore) {
+			this.tmCore = await createTaskMasterCore({ projectPath: projectRoot });
+		}
+	}
+
+	/**
+	 * Load task from tm-core
+	 */
+	private async loadTask(taskId: string): Promise<Task | null> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+
+		try {
+			const { task } = await this.tmCore.getTaskWithSubtask(taskId);
+			return task;
+		} catch (error) {
+			return null;
+		}
+	}
+
+	/**
+	 * Display task information before execution
+	 */
+	private displayTaskInfo(task: Task, isDryRun: boolean): void {
+		const prefix = isDryRun ? '[DRY RUN] ' : '';
+		console.log();
+		console.log(
+			boxen(
+				chalk.cyan.bold(`${prefix}Autopilot Task Execution`) +
+					'\n\n' +
+					chalk.white(`Task ID: ${task.id}`) +
+					'\n' +
+					chalk.white(`Title: ${task.title}`) +
+					'\n' +
+					chalk.white(`Status: ${task.status}`) +
+					(task.description ? '\n\n' + chalk.gray(task.description) : ''),
+				{
+					padding: 1,
+					borderStyle: 'round',
+					borderColor: 'cyan',
+					width: process.stdout.columns ? process.stdout.columns * 0.95 : 100
+				}
+			)
+		);
+		console.log();
+	}
+
+	/**
+	 * Perform autopilot execution using PreflightChecker and TaskLoader
+	 */
+	private async performAutopilot(
+		taskId: string,
+		task: Task,
+		options: AutopilotCommandOptions
+	): Promise<AutopilotCommandResult> {
+		// Run preflight checks
+		const preflightResult = await this.runPreflightChecks(options);
+		if (!preflightResult.success) {
+			return {
+				success: false,
+				taskId,
+				task,
+				error: 'Preflight checks failed',
+				message: 'Please resolve the issues above before running autopilot'
+			};
+		}
+
+		// Validate task structure and get execution order
+		const validationResult = await this.validateTaskStructure(
+			taskId,
+			task,
+			options
+		);
+		if (!validationResult.success) {
+			return validationResult;
+		}
+
+		// Display execution plan
+		this.displayExecutionPlan(
+			validationResult.task!,
+			validationResult.orderedSubtasks!,
+			options
+		);
+
+		return {
+			success: true,
+			taskId,
+			task: validationResult.task,
+			message: options.dryRun
+				? 'Dry run completed successfully'
+				: 'Autopilot execution ready (actual execution not yet implemented)'
+		};
+	}
+
+	/**
+	 * Run preflight checks and display results
+	 */
+	private async runPreflightChecks(
+		options: AutopilotCommandOptions
+	): Promise<PreflightResult> {
+		const { PreflightChecker } = await import('@tm/core');
+
+		console.log();
+		console.log(chalk.cyan.bold('Running preflight checks...'));
+
+		const preflightChecker = new PreflightChecker(
+			options.project || process.cwd()
+		);
+		const result = await preflightChecker.runAllChecks();
+
+		this.displayPreflightResults(result);
+
+		return result;
+	}
+
+	/**
+	 * Validate task structure and get execution order
+	 */
+	private async validateTaskStructure(
+		taskId: string,
+		task: Task,
+		options: AutopilotCommandOptions
+	): Promise<AutopilotCommandResult & { orderedSubtasks?: Subtask[] }> {
+		const { TaskLoaderService } = await import('@tm/core');
+
+		console.log();
+		console.log(chalk.cyan.bold('Validating task structure...'));
+
+		const taskLoader = new TaskLoaderService(options.project || process.cwd());
+		const validationResult = await taskLoader.loadAndValidateTask(taskId);
+
+		if (!validationResult.success) {
+			await taskLoader.cleanup();
+			return {
+				success: false,
+				taskId,
+				task,
+				error: validationResult.errorMessage,
+				message: validationResult.suggestion
+			};
+		}
+
+		const orderedSubtasks = taskLoader.getExecutionOrder(
+			validationResult.task!
+		);
+
+		await taskLoader.cleanup();
+
+		return {
+			success: true,
+			taskId,
+			task: validationResult.task,
+			orderedSubtasks
+		};
+	}
+
+	/**
+	 * Display execution plan with subtasks and TDD workflow
+	 */
+	private displayExecutionPlan(
+		task: Task,
+		orderedSubtasks: Subtask[],
+		options: AutopilotCommandOptions
+	): void {
+		console.log();
+		console.log(chalk.green.bold('✓ All checks passed!'));
+		console.log();
+		console.log(chalk.cyan.bold('Execution Plan:'));
+		console.log(chalk.white(`Task: ${task.title}`));
+		console.log(
+			chalk.gray(
+				`${orderedSubtasks.length} subtasks will be executed in dependency order`
+			)
+		);
+		console.log();
+
+		// Display subtasks
+		orderedSubtasks.forEach((subtask: Subtask, index: number) => {
+			console.log(
+				chalk.yellow(`${index + 1}. ${task.id}.${subtask.id}: ${subtask.title}`)
+			);
+			if (subtask.dependencies && subtask.dependencies.length > 0) {
+				console.log(
+					chalk.gray(`   Dependencies: ${subtask.dependencies.join(', ')}`)
+				);
+			}
+		});
+
+		console.log();
+		console.log(
+			chalk.cyan('Autopilot would execute each subtask using TDD workflow:')
+		);
+		console.log(chalk.gray('  1. RED phase: Write failing test'));
+		console.log(chalk.gray('  2. GREEN phase: Implement code to pass test'));
+		console.log(chalk.gray('  3. COMMIT phase: Commit changes'));
+		console.log();
+
+		if (options.dryRun) {
+			console.log(
+				chalk.yellow('This was a dry run. Use without --dry-run to execute.')
+			);
+		}
+	}
+
+	/**
+	 * Display preflight check results
+	 */
+	private displayPreflightResults(result: PreflightResult): void {
+		const checks = [
+			{ name: 'Test command', result: result.testCommand },
+			{ name: 'Git working tree', result: result.gitWorkingTree },
+			{ name: 'Required tools', result: result.requiredTools },
+			{ name: 'Default branch', result: result.defaultBranch }
+		];
+
+		checks.forEach((check) => {
+			const icon = check.result.success ? chalk.green('✓') : chalk.red('✗');
+			const status = check.result.success
+				? chalk.green('PASS')
+				: chalk.red('FAIL');
+			console.log(`${icon} ${chalk.white(check.name)}: ${status}`);
+			if (check.result.message) {
+				console.log(chalk.gray(`  ${check.result.message}`));
+			}
+		});
+	}
+
+	/**
+	 * Display results based on format
+	 */
+	private displayResults(
+		result: AutopilotCommandResult,
+		options: AutopilotCommandOptions
+	): void {
+		const format = options.format || 'text';
+
+		switch (format) {
+			case 'json':
+				this.displayJson(result);
+				break;
+
+			case 'text':
+			default:
+				this.displayTextResult(result);
+				break;
+		}
+	}
+
+	/**
+	 * Display in JSON format
+	 */
+	private displayJson(result: AutopilotCommandResult): void {
+		console.log(JSON.stringify(result, null, 2));
+	}
+
+	/**
+	 * Display result in text format
+	 */
+	private displayTextResult(result: AutopilotCommandResult): void {
+		if (result.success) {
+			console.log(
+				boxen(
+					chalk.green.bold('✓ Autopilot Command Completed') +
+						'\n\n' +
+						chalk.white(result.message || 'Execution complete'),
+					{
+						padding: 1,
+						borderStyle: 'round',
+						borderColor: 'green',
+						margin: { top: 1 }
+					}
+				)
+			);
+		} else {
+			console.log(
+				boxen(
+					chalk.red.bold('✗ Autopilot Command Failed') +
+						'\n\n' +
+						chalk.white(result.error || 'Unknown error'),
+					{
+						padding: 1,
+						borderStyle: 'round',
+						borderColor: 'red',
+						margin: { top: 1 }
+					}
+				)
+			);
+		}
+	}
+
+	/**
+	 * Handle general errors
+	 */
+	private handleError(error: unknown): void {
+		const errorObj = error as {
+			getSanitizedDetails?: () => { message: string };
+			message?: string;
+			stack?: string;
+		};
+
+		const msg = errorObj?.getSanitizedDetails?.() ?? {
+			message: errorObj?.message ?? String(error)
+		};
+		console.error(chalk.red(`Error: ${msg.message || 'Unexpected error'}`));
+
+		// Show stack trace in development mode or when DEBUG is set
+		const isDevelopment = process.env.NODE_ENV !== 'production';
+		if ((isDevelopment || process.env.DEBUG) && errorObj.stack) {
+			console.error(chalk.gray(errorObj.stack));
+		}
+	}
+
+	/**
+	 * Set the last result for programmatic access
+	 */
+	private setLastResult(result: AutopilotCommandResult): void {
+		this.lastResult = result;
+	}
+
+	/**
+	 * Get the last result (for programmatic usage)
+	 */
+	getLastResult(): AutopilotCommandResult | undefined {
+		return this.lastResult;
+	}
+
+	/**
+	 * Clean up resources
+	 */
+	async cleanup(): Promise<void> {
+		if (this.tmCore) {
+			await this.tmCore.close();
+			this.tmCore = undefined;
+		}
+	}
+
+	/**
+	 * Register this command on an existing program
+	 */
+	static register(program: Command, name?: string): AutopilotCommand {
+		const autopilotCommand = new AutopilotCommand(name);
+		program.addCommand(autopilotCommand);
+		return autopilotCommand;
+	}
+}

apps/cli/src/commands/autopilot/abort.command.ts

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Abort Command - Safely terminate workflow
+ */
+
+import { Command } from 'commander';
+import { WorkflowOrchestrator } from '@tm/core';
+import {
+	AutopilotBaseOptions,
+	hasWorkflowState,
+	loadWorkflowState,
+	deleteWorkflowState,
+	OutputFormatter
+} from './shared.js';
+import inquirer from 'inquirer';
+
+interface AbortOptions extends AutopilotBaseOptions {
+	force?: boolean;
+}
+
+/**
+ * Abort Command - Safely terminate workflow and clean up state
+ */
+export class AbortCommand extends Command {
+	constructor() {
+		super('abort');
+
+		this.description('Abort the current TDD workflow and clean up state')
+			.option('-f, --force', 'Force abort without confirmation')
+			.action(async (options: AbortOptions) => {
+				await this.execute(options);
+			});
+	}
+
+	private async execute(options: AbortOptions): Promise<void> {
+		// Inherit parent options
+		const parentOpts = this.parent?.opts() as AutopilotBaseOptions;
+		const mergedOptions: AbortOptions = {
+			...parentOpts,
+			...options,
+			projectRoot:
+				options.projectRoot || parentOpts?.projectRoot || process.cwd()
+		};
+
+		const formatter = new OutputFormatter(mergedOptions.json || false);
+
+		try {
+			// Check for workflow state
+			const hasState = await hasWorkflowState(mergedOptions.projectRoot!);
+			if (!hasState) {
+				formatter.warning('No active workflow to abort');
+				return;
+			}
+
+			// Load state
+			const state = await loadWorkflowState(mergedOptions.projectRoot!);
+			if (!state) {
+				formatter.error('Failed to load workflow state');
+				process.exit(1);
+			}
+
+			// Restore orchestrator
+			const orchestrator = new WorkflowOrchestrator(state.context);
+			orchestrator.restoreState(state);
+
+			// Get progress before abort
+			const progress = orchestrator.getProgress();
+			const currentSubtask = orchestrator.getCurrentSubtask();
+
+			// Confirm abort if not forced or in JSON mode
+			if (!mergedOptions.force && !mergedOptions.json) {
+				const { confirmed } = await inquirer.prompt([
+					{
+						type: 'confirm',
+						name: 'confirmed',
+						message:
+							`This will abort the workflow for task ${state.context.taskId}. ` +
+							`Progress: ${progress.completed}/${progress.total} subtasks completed. ` +
+							`Continue?`,
+						default: false
+					}
+				]);
+
+				if (!confirmed) {
+					formatter.info('Abort cancelled');
+					return;
+				}
+			}
+
+			// Trigger abort in orchestrator
+			orchestrator.transition({ type: 'ABORT' });
+
+			// Delete workflow state
+			await deleteWorkflowState(mergedOptions.projectRoot!);
+
+			// Output result
+			formatter.success('Workflow aborted', {
+				taskId: state.context.taskId,
+				branchName: state.context.branchName,
+				progress: {
+					completed: progress.completed,
+					total: progress.total
+				},
+				lastSubtask: currentSubtask
+					? {
+							id: currentSubtask.id,
+							title: currentSubtask.title
+						}
+					: null,
+				note: 'Branch and commits remain. Clean up manually if needed.'
+			});
+		} catch (error) {
+			formatter.error((error as Error).message);
+			if (mergedOptions.verbose) {
+				console.error((error as Error).stack);
+			}
+			process.exit(1);
+		}
+	}
+}

apps/cli/src/commands/autopilot/commit.command.ts

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview Commit Command - Create commit with enhanced message generation
+ */
+
+import { Command } from 'commander';
+import { WorkflowOrchestrator } from '@tm/core';
+import {
+	AutopilotBaseOptions,
+	hasWorkflowState,
+	loadWorkflowState,
+	createGitAdapter,
+	createCommitMessageGenerator,
+	OutputFormatter,
+	saveWorkflowState
+} from './shared.js';
+
+type CommitOptions = AutopilotBaseOptions;
+
+/**
+ * Commit Command - Create commit using enhanced message generator
+ */
+export class CommitCommand extends Command {
+	constructor() {
+		super('commit');
+
+		this.description('Create a commit for the completed GREEN phase').action(
+			async (options: CommitOptions) => {
+				await this.execute(options);
+			}
+		);
+	}
+
+	private async execute(options: CommitOptions): Promise<void> {
+		// Inherit parent options
+		const parentOpts = this.parent?.opts() as AutopilotBaseOptions;
+		const mergedOptions: CommitOptions = {
+			...parentOpts,
+			...options,
+			projectRoot:
+				options.projectRoot || parentOpts?.projectRoot || process.cwd()
+		};
+
+		const formatter = new OutputFormatter(mergedOptions.json || false);
+
+		try {
+			// Check for workflow state
+			const hasState = await hasWorkflowState(mergedOptions.projectRoot!);
+			if (!hasState) {
+				formatter.error('No active workflow', {
+					suggestion: 'Start a workflow with: autopilot start <taskId>'
+				});
+				process.exit(1);
+			}
+
+			// Load state
+			const state = await loadWorkflowState(mergedOptions.projectRoot!);
+			if (!state) {
+				formatter.error('Failed to load workflow state');
+				process.exit(1);
+			}
+
+			const orchestrator = new WorkflowOrchestrator(state.context);
+			orchestrator.restoreState(state);
+			orchestrator.enableAutoPersist(async (newState) => {
+				await saveWorkflowState(mergedOptions.projectRoot!, newState);
+			});
+
+			// Verify in COMMIT phase
+			const tddPhase = orchestrator.getCurrentTDDPhase();
+			if (tddPhase !== 'COMMIT') {
+				formatter.error('Not in COMMIT phase', {
+					currentPhase: tddPhase || orchestrator.getCurrentPhase(),
+					suggestion: 'Complete RED and GREEN phases first'
+				});
+				process.exit(1);
+			}
+
+			// Get current subtask
+			const currentSubtask = orchestrator.getCurrentSubtask();
+			if (!currentSubtask) {
+				formatter.error('No current subtask');
+				process.exit(1);
+			}
+
+			// Initialize git adapter
+			const gitAdapter = createGitAdapter(mergedOptions.projectRoot!);
+			await gitAdapter.ensureGitRepository();
+
+			// Check for staged changes
+			const hasStagedChanges = await gitAdapter.hasStagedChanges();
+			if (!hasStagedChanges) {
+				// Stage all changes
+				formatter.info('No staged changes, staging all changes...');
+				await gitAdapter.stageFiles(['.']);
+			}
+
+			// Get changed files for scope detection
+			const status = await gitAdapter.getStatus();
+			const changedFiles = [...status.staged, ...status.modified];
+
+			// Generate commit message
+			const messageGenerator = createCommitMessageGenerator();
+			const testResults = state.context.lastTestResults;
+
+			const commitMessage = messageGenerator.generateMessage({
+				type: 'feat',
+				description: currentSubtask.title,
+				changedFiles,
+				taskId: state.context.taskId,
+				phase: 'TDD',
+				tag: (state.context.metadata.tag as string) || undefined,
+				testsPassing: testResults?.passed,
+				testsFailing: testResults?.failed,
+				coveragePercent: undefined // Could be added if available
+			});
+
+			// Create commit with metadata
+			await gitAdapter.createCommit(commitMessage, {
+				metadata: {
+					taskId: state.context.taskId,
+					subtaskId: currentSubtask.id,
+					phase: 'COMMIT',
+					tddCycle: 'complete'
+				}
+			});
+
+			// Get commit info
+			const lastCommit = await gitAdapter.getLastCommit();
+
+			// Complete COMMIT phase (this marks subtask as completed)
+			orchestrator.transition({ type: 'COMMIT_COMPLETE' });
+
+			// Check if should advance to next subtask
+			const progress = orchestrator.getProgress();
+			if (progress.current < progress.total) {
+				orchestrator.transition({ type: 'SUBTASK_COMPLETE' });
+			} else {
+				// All subtasks complete
+				orchestrator.transition({ type: 'ALL_SUBTASKS_COMPLETE' });
+			}
+
+			// Output success
+			formatter.success('Commit created', {
+				commitHash: lastCommit.hash.substring(0, 7),
+				message: commitMessage.split('\n')[0], // First line only
+				subtask: {
+					id: currentSubtask.id,
+					title: currentSubtask.title,
+					status: currentSubtask.status
+				},
+				progress: {
+					completed: progress.completed,
+					total: progress.total,
+					percentage: progress.percentage
+				},
+				nextAction:
+					progress.completed < progress.total
+						? 'Start next subtask with RED phase'
+						: 'All subtasks complete. Run: autopilot status'
+			});
+		} catch (error) {
+			formatter.error((error as Error).message);
+			if (mergedOptions.verbose) {
+				console.error((error as Error).stack);
+			}
+			process.exit(1);
+		}
+	}
+}

apps/cli/src/commands/autopilot/complete.command.ts

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview Complete Command - Complete current TDD phase with validation
+ */
+
+import { Command } from 'commander';
+import { WorkflowOrchestrator, TestResult } from '@tm/core';
+import {
+	AutopilotBaseOptions,
+	hasWorkflowState,
+	loadWorkflowState,
+	OutputFormatter
+} from './shared.js';
+
+interface CompleteOptions extends AutopilotBaseOptions {
+	results?: string;
+	coverage?: string;
+}
+
+/**
+ * Complete Command - Mark current phase as complete with validation
+ */
+export class CompleteCommand extends Command {
+	constructor() {
+		super('complete');
+
+		this.description('Complete the current TDD phase with result validation')
+			.option(
+				'-r, --results <json>',
+				'Test results JSON (with total, passed, failed, skipped)'
+			)
+			.option('-c, --coverage <percent>', 'Coverage percentage')
+			.action(async (options: CompleteOptions) => {
+				await this.execute(options);
+			});
+	}
+
+	private async execute(options: CompleteOptions): Promise<void> {
+		// Inherit parent options
+		const parentOpts = this.parent?.opts() as AutopilotBaseOptions;
+		const mergedOptions: CompleteOptions = {
+			...parentOpts,
+			...options,
+			projectRoot:
+				options.projectRoot || parentOpts?.projectRoot || process.cwd()
+		};
+
+		const formatter = new OutputFormatter(mergedOptions.json || false);
+
+		try {
+			// Check for workflow state
+			const hasState = await hasWorkflowState(mergedOptions.projectRoot!);
+			if (!hasState) {
+				formatter.error('No active workflow', {
+					suggestion: 'Start a workflow with: autopilot start <taskId>'
+				});
+				process.exit(1);
+			}
+
+			// Load state
+			const state = await loadWorkflowState(mergedOptions.projectRoot!);
+			if (!state) {
+				formatter.error('Failed to load workflow state');
+				process.exit(1);
+			}
+
+			// Restore orchestrator with persistence
+			const { saveWorkflowState } = await import('./shared.js');
+			const orchestrator = new WorkflowOrchestrator(state.context);
+			orchestrator.restoreState(state);
+			orchestrator.enableAutoPersist(async (newState) => {
+				await saveWorkflowState(mergedOptions.projectRoot!, newState);
+			});
+
+			// Get current phase
+			const tddPhase = orchestrator.getCurrentTDDPhase();
+			const currentSubtask = orchestrator.getCurrentSubtask();
+
+			if (!tddPhase) {
+				formatter.error('Not in a TDD phase', {
+					phase: orchestrator.getCurrentPhase()
+				});
+				process.exit(1);
+			}
+
+			// Validate based on phase
+			if (tddPhase === 'RED' || tddPhase === 'GREEN') {
+				if (!mergedOptions.results) {
+					formatter.error('Test results required for RED/GREEN phase', {
+						usage:
+							'--results \'{"total":10,"passed":9,"failed":1,"skipped":0}\''
+					});
+					process.exit(1);
+				}
+
+				// Parse test results
+				let testResults: TestResult;
+				try {
+					const parsed = JSON.parse(mergedOptions.results);
+					testResults = {
+						total: parsed.total || 0,
+						passed: parsed.passed || 0,
+						failed: parsed.failed || 0,
+						skipped: parsed.skipped || 0,
+						phase: tddPhase
+					};
+				} catch (error) {
+					formatter.error('Invalid test results JSON', {
+						error: (error as Error).message
+					});
+					process.exit(1);
+				}
+
+				// Validate RED phase requirements
+				if (tddPhase === 'RED' && testResults.failed === 0) {
+					formatter.error('RED phase validation failed', {
+						reason: 'At least one test must be failing',
+						actual: {
+							passed: testResults.passed,
+							failed: testResults.failed
+						}
+					});
+					process.exit(1);
+				}
+
+				// Validate GREEN phase requirements
+				if (tddPhase === 'GREEN' && testResults.failed !== 0) {
+					formatter.error('GREEN phase validation failed', {
+						reason: 'All tests must pass',
+						actual: {
+							passed: testResults.passed,
+							failed: testResults.failed
+						}
+					});
+					process.exit(1);
+				}
+
+				// Complete phase with test results
+				if (tddPhase === 'RED') {
+					orchestrator.transition({
+						type: 'RED_PHASE_COMPLETE',
+						testResults
+					});
+					formatter.success('RED phase completed', {
+						nextPhase: 'GREEN',
+						testResults,
+						subtask: currentSubtask?.title
+					});
+				} else {
+					orchestrator.transition({
+						type: 'GREEN_PHASE_COMPLETE',
+						testResults
+					});
+					formatter.success('GREEN phase completed', {
+						nextPhase: 'COMMIT',
+						testResults,
+						subtask: currentSubtask?.title,
+						suggestion: 'Run: autopilot commit'
+					});
+				}
+			} else if (tddPhase === 'COMMIT') {
+				formatter.error('Use "autopilot commit" to complete COMMIT phase');
+				process.exit(1);
+			}
+		} catch (error) {
+			formatter.error((error as Error).message);
+			if (mergedOptions.verbose) {
+				console.error((error as Error).stack);
+			}
+			process.exit(1);
+		}
+	}
+}

apps/cli/src/commands/autopilot/index.ts

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Autopilot CLI Commands for AI Agent Orchestration
+ * Provides subcommands for starting, resuming, and advancing the TDD workflow
+ * with JSON output for machine parsing.
+ */
+
+import { Command } from 'commander';
+import { StartCommand } from './start.command.js';
+import { ResumeCommand } from './resume.command.js';
+import { NextCommand } from './next.command.js';
+import { CompleteCommand } from './complete.command.js';
+import { CommitCommand } from './commit.command.js';
+import { StatusCommand } from './status.command.js';
+import { AbortCommand } from './abort.command.js';
+
+/**
+ * Shared command options for all autopilot commands
+ */
+export interface AutopilotBaseOptions {
+	json?: boolean;
+	verbose?: boolean;
+	projectRoot?: string;
+}
+
+/**
+ * AutopilotCommand with subcommands for TDD workflow orchestration
+ */
+export class AutopilotCommand extends Command {
+	constructor() {
+		super('autopilot');
+
+		// Configure main command
+		this.description('AI agent orchestration for TDD workflow execution')
+			.alias('ap')
+			// Global options for all subcommands
+			.option('--json', 'Output in JSON format for machine parsing')
+			.option('-v, --verbose', 'Enable verbose output')
+			.option(
+				'-p, --project-root <path>',
+				'Project root directory',
+				process.cwd()
+			);
+
+		// Register subcommands
+		this.registerSubcommands();
+	}
+
+	/**
+	 * Register all autopilot subcommands
+	 */
+	private registerSubcommands(): void {
+		// Start new TDD workflow
+		this.addCommand(new StartCommand());
+
+		// Resume existing workflow
+		this.addCommand(new ResumeCommand());
+
+		// Get next action
+		this.addCommand(new NextCommand());
+
+		// Complete current phase
+		this.addCommand(new CompleteCommand());
+
+		// Create commit
+		this.addCommand(new CommitCommand());
+
+		// Show status
+		this.addCommand(new StatusCommand());
+
+		// Abort workflow
+		this.addCommand(new AbortCommand());
+	}
+
+	/**
+	 * Register this command on an existing program
+	 */
+	static register(program: Command): AutopilotCommand {
+		const autopilotCommand = new AutopilotCommand();
+		program.addCommand(autopilotCommand);
+		return autopilotCommand;
+	}
+}

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

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview Next Command - Get next action in TDD workflow
+ */
+
+import { Command } from 'commander';
+import { WorkflowOrchestrator } from '@tm/core';
+import {
+	AutopilotBaseOptions,
+	hasWorkflowState,
+	loadWorkflowState,
+	OutputFormatter
+} from './shared.js';
+
+type NextOptions = AutopilotBaseOptions;
+
+/**
+ * Next Command - Get next action details
+ */
+export class NextCommand extends Command {
+	constructor() {
+		super('next');
+
+		this.description(
+			'Get the next action to perform in the TDD workflow'
+		).action(async (options: NextOptions) => {
+			await this.execute(options);
+		});
+	}
+
+	private async execute(options: NextOptions): Promise<void> {
+		// Inherit parent options
+		const parentOpts = this.parent?.opts() as AutopilotBaseOptions;
+		const mergedOptions: NextOptions = {
+			...parentOpts,
+			...options,
+			projectRoot:
+				options.projectRoot || parentOpts?.projectRoot || process.cwd()
+		};
+
+		const formatter = new OutputFormatter(mergedOptions.json || false);
+
+		try {
+			// Check for workflow state
+			const hasState = await hasWorkflowState(mergedOptions.projectRoot!);
+			if (!hasState) {
+				formatter.error('No active workflow', {
+					suggestion: 'Start a workflow with: autopilot start <taskId>'
+				});
+				process.exit(1);
+			}
+
+			// Load state
+			const state = await loadWorkflowState(mergedOptions.projectRoot!);
+			if (!state) {
+				formatter.error('Failed to load workflow state');
+				process.exit(1);
+			}
+
+			// Restore orchestrator
+			const orchestrator = new WorkflowOrchestrator(state.context);
+			orchestrator.restoreState(state);
+
+			// Get current phase and subtask
+			const phase = orchestrator.getCurrentPhase();
+			const tddPhase = orchestrator.getCurrentTDDPhase();
+			const currentSubtask = orchestrator.getCurrentSubtask();
+
+			// Determine next action based on phase
+			let actionType: string;
+			let actionDescription: string;
+			let actionDetails: Record<string, unknown> = {};
+
+			if (phase === 'COMPLETE') {
+				formatter.success('Workflow complete', {
+					message: 'All subtasks have been completed',
+					taskId: state.context.taskId
+				});
+				return;
+			}
+
+			if (phase === 'SUBTASK_LOOP' && tddPhase) {
+				switch (tddPhase) {
+					case 'RED':
+						actionType = 'generate_test';
+						actionDescription = 'Write failing test for current subtask';
+						actionDetails = {
+							subtask: currentSubtask
+								? {
+										id: currentSubtask.id,
+										title: currentSubtask.title,
+										attempts: currentSubtask.attempts
+									}
+								: null,
+							testCommand: 'npm test', // Could be customized based on config
+							expectedOutcome: 'Test should fail'
+						};
+						break;
+
+					case 'GREEN':
+						actionType = 'implement_code';
+						actionDescription = 'Implement code to pass the failing test';
+						actionDetails = {
+							subtask: currentSubtask
+								? {
+										id: currentSubtask.id,
+										title: currentSubtask.title,
+										attempts: currentSubtask.attempts
+									}
+								: null,
+							testCommand: 'npm test',
+							expectedOutcome: 'All tests should pass',
+							lastTestResults: state.context.lastTestResults
+						};
+						break;
+
+					case 'COMMIT':
+						actionType = 'commit_changes';
+						actionDescription = 'Commit the changes';
+						actionDetails = {
+							subtask: currentSubtask
+								? {
+										id: currentSubtask.id,
+										title: currentSubtask.title,
+										attempts: currentSubtask.attempts
+									}
+								: null,
+							suggestion: 'Use: autopilot commit'
+						};
+						break;
+
+					default:
+						actionType = 'unknown';
+						actionDescription = 'Unknown TDD phase';
+				}
+			} else {
+				actionType = 'workflow_phase';
+				actionDescription = `Currently in ${phase} phase`;
+			}
+
+			// Output next action
+			const output = {
+				action: actionType,
+				description: actionDescription,
+				phase,
+				tddPhase,
+				taskId: state.context.taskId,
+				branchName: state.context.branchName,
+				...actionDetails
+			};
+
+			if (mergedOptions.json) {
+				formatter.output(output);
+			} else {
+				formatter.success('Next action', output);
+			}
+		} catch (error) {
+			formatter.error((error as Error).message);
+			if (mergedOptions.verbose) {
+				console.error((error as Error).stack);
+			}
+			process.exit(1);
+		}
+	}
+}