chore: fix build issues (#1274)

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: Ben Vargas <ben@example.com>

.changeset/chore-fix-docs.md

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

.changeset/claude-code-json-truncation.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Recover from `@anthropic-ai/claude-code` JSON truncation bug that caused Task Master to crash when handling large (>8 kB) structured responses.  The CLI/SDK still truncates, but Task Master now detects the error, preserves buffered text, and returns a usable response instead of throwing. 

.changeset/config.json

@@ -2,13 +2,15 @@
   "$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"
-}
+  ]
+}

.changeset/cuddly-baboons-invent.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Updating dependency ai-sdk-provider-gemini-cli to 0.0.4 to address breaking change Google made to Gemini CLI and add better 'api-key' in addition to 'gemini-api-key' AI-SDK compatibility.

.changeset/cursor-slash-commands.md

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

.changeset/curvy-weeks-flow.md

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

.changeset/easy-spiders-wave.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": patch
+---
+
+Do a quick fix on build

.changeset/flat-cities-say.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": minor
+---
+
+Added api keys page on docs website: docs.task-master.dev/getting-started/api-keys

.changeset/forty-tables-invite.md

@@ -0,0 +1,10 @@
+---
+"task-master-ai": minor
+---
+
+Move to AI SDK v5:
+
+- Works better with claude-code and gemini-cli as ai providers
+- Improved openai model family compatibility
+- Migrate ollama provider to v2
+- Closes #1223, #1013, #1161, #1174

.changeset/gentle-cats-dance.md

@@ -0,0 +1,30 @@
+---
+"task-master-ai": minor
+---
+
+Migrate AI services to use generateObject for structured data generation
+
+This update migrates all AI service calls from generateText to generateObject, ensuring more reliable and structured responses across all commands.
+
+### Key Changes:
+
+- **Unified AI Service**: Replaced separate generateText implementations with a single generateObjectService that handles structured data generation
+- **JSON Mode Support**: Added proper JSON mode configuration for providers that support it (OpenAI, Anthropic, Google, Groq)
+- **Schema Validation**: Integrated Zod schemas for all AI-generated content with automatic validation
+- **Provider Compatibility**: Maintained compatibility with all existing providers while leveraging their native structured output capabilities
+- **Improved Reliability**: Structured output generation reduces parsing errors and ensures consistent data formats
+
+### Technical Improvements:
+
+- Centralized provider configuration in `ai-providers-unified.js`
+- Added `generateObject` support detection for each provider
+- Implemented proper error handling for schema validation failures
+- Maintained backward compatibility with existing prompt structures
+
+### Bug Fixes:
+
+- Fixed subtask ID numbering issue where AI was generating inconsistent IDs (101-105, 601-603) instead of sequential numbering (1, 2, 3...)
+- Enhanced prompt instructions to enforce proper ID generation patterns
+- Ensured subtasks display correctly as X.1, X.2, X.3 format
+
+This migration improves the reliability and consistency of AI-generated content throughout the Task Master application.

.changeset/grok-4-support.md

@@ -1,9 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add support for xAI Grok 4 model
-
-- Add grok-4 model to xAI provider with $3/$15 per 1M token pricing
-- Enable main, fallback, and research roles for grok-4
-- Max tokens set to 131,072 (matching other xAI models)

.changeset/mcp-timeout-configuration.md

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

.changeset/petite-ideas-grab.md

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

.changeset/pre.json

@@ -0,0 +1,22 @@
+{
+  "mode": "pre",
+  "tag": "rc",
+  "initialVersions": {
+    "task-master-ai": "0.27.3",
+    "docs": "0.0.4",
+    "extension": "0.25.4"
+  },
+  "changesets": [
+    "chore-fix-docs",
+    "cursor-slash-commands",
+    "curvy-weeks-flow",
+    "flat-cities-say",
+    "forty-tables-invite",
+    "gentle-cats-dance",
+    "mcp-timeout-configuration",
+    "petite-ideas-grab",
+    "silly-pandas-find",
+    "sweet-maps-rule",
+    "whole-pigs-say"
+  ]
+}

.changeset/quick-laws-cover.md

@@ -1,8 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add stricter validation and clearer feedback for task priority when adding new tasks
-
-- if a task priority is invalid, it will default to medium
-- made taks priority case-insensitive, essentially making HIGH and high the same value

.changeset/silly-pandas-find.md

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

.changeset/some-lies-grin.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add support for MCP Sampling as AI provider, requires no API key, uses the client LLM provider

.changeset/spicy-badgers-fail.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Unify and streamline profile system architecture for improved maintainability

.changeset/sweet-maps-rule.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": minor
+---
+
+Upgrade grok-cli ai provider to ai sdk v5

.changeset/tender-ads-joke.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Added Groq provider support

.changeset/whole-pigs-say.md

@@ -0,0 +1,8 @@
+---
+"task-master-ai": patch
+---
+
+Fix complexity score not showing for `task-master show` and `task-master list`
+
+- Added complexity score on "next task" when running `task-master list`
+- Added colors to complexity to reflect complexity (easy, medium, hard)

.claude/agents/task-checker.md

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

.claude/agents/task-executor.md

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

.claude/agents/task-orchestrator.md

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

.claude/commands/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/index.md

@@ -1,130 +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`
-- `index` - Initialize new project (handles PRD files intelligently)
-- `quick` - Quick setup with auto-confirmation (-y flag)
-
-### `/project:tm/models`
-- `index` - View current AI model configuration
-- `setup` - 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`
-- `index` - Generate tasks from PRD document
-- `with-research` - Enhanced parsing with research mode
-
-### `/project:tm/generate`
-- Create individual task files from tasks.json
-
-## Task Management
-
-### `/project:tm/list`
-- `index` - Smart listing with natural language filters
-- `with-subtasks` - Include subtasks in hierarchical view
-- `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`
-- Export tasks to README.md with formatting
-
-### `/project:tm/update`
-- `index` - Update tasks with natural language
-- `from-id` - Update multiple tasks from a starting point
-- `single` - Update specific task
-
-### `/project:tm/add-task`
-- `index` - Add new task with AI assistance
-
-### `/project:tm/remove-task`
-- `index` - Remove task with confirmation
-
-## Subtask Management
-
-### `/project:tm/add-subtask`
-- `index` - Add new subtask to parent
-- `from-task` - Convert existing task to subtask
-
-### `/project:tm/remove-subtask`
-- Remove subtask (with optional conversion)
-
-### `/project:tm/clear-subtasks`
-- `index` - Clear subtasks from specific task
-- `all` - Clear all subtasks globally
-
-## Task Analysis & Breakdown
-
-### `/project:tm/analyze-complexity`
-- Analyze and generate expansion recommendations
-
-### `/project:tm/complexity-report`
-- Display complexity analysis report
-
-### `/project:tm/expand`
-- `index` - Break down specific task
-- `all` - Expand all eligible tasks
-- `with-research` - Enhanced expansion
-
-## Task Navigation
-
-### `/project:tm/next`
-- Intelligent next task recommendation
-
-### `/project:tm/show`
-- Display detailed task information
-
-### `/project:tm/status`
-- Comprehensive project dashboard
-
-## Dependency Management
-
-### `/project:tm/add-dependency`
-- Add task dependency
-
-### `/project:tm/remove-dependency`
-- Remove task dependency
-
-### `/project:tm/validate-dependencies`
-- Check for dependency issues
-
-### `/project:tm/fix-dependencies`
-- Automatically fix dependency problems
-
-## 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/tm-main.md

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

.coderabbit.yaml

@@ -0,0 +1,10 @@
+reviews:
+  profile: assertive
+  poem: false
+  auto_review:
+    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/commands.mdc

@@ -523,7 +523,7 @@ For AI-powered commands that benefit from project context, follow the research c
     .option('--details <details>', 'Implementation details for the new subtask, optional')
     .option('--dependencies <ids>', 'Comma-separated list of subtask IDs this subtask depends on')
     .option('--status <status>', 'Initial status for the subtask', 'pending')
-    .option('--skip-generate', 'Skip regenerating task files')
+    .option('--generate', 'Regenerate task files after adding subtask')
     .action(async (options) => {
       // Validate required parameters
       if (!options.parent) {
@@ -545,7 +545,7 @@ For AI-powered commands that benefit from project context, follow the research c
     .option('-f, --file <path>', 'Path to the tasks file', 'tasks/tasks.json')
     .option('-i, --id <id>', 'ID of the subtask to remove in format parentId.subtaskId, required')
     .option('-c, --convert', 'Convert the subtask to a standalone task instead of deleting')
-    .option('--skip-generate', 'Skip regenerating task files')
+    .option('--generate', 'Regenerate task files after removing subtask')
     .action(async (options) => {
       // Implementation with detailed error handling
     })
@@ -633,11 +633,11 @@ function showAddSubtaskHelp() {
     '  --dependencies <ids>      Comma-separated list of dependency IDs\n' +
     '  -s, --status <status>     Status for the new subtask (default: "pending")\n' +
     '  -f, --file <file>         Path to the tasks file (default: "tasks/tasks.json")\n' +
-    '  --skip-generate           Skip regenerating task files\n\n' +
+    '  --generate                Regenerate task files after adding subtask\n\n' +
     chalk.cyan('Examples:') + '\n' +
     '  task-master add-subtask --parent=\'5\' --task-id=\'8\'\n' +
     '  task-master add-subtask -p \'5\' -t \'Implement login UI\' -d \'Create the login form\'\n' +
-    '  task-master add-subtask -p \'5\' -t \'Handle API Errors\' --details $\'Handle 401 Unauthorized.\nHandle 500 Server Error.\'',
+    '  task-master add-subtask -p \'5\' -t \'Handle API Errors\' --details "Handle 401 Unauthorized.\\nHandle 500 Server Error." --generate',
     { padding: 1, borderColor: 'blue', borderStyle: 'round' }
   ));
 }
@@ -652,7 +652,7 @@ function showRemoveSubtaskHelp() {
     '  -i, --id <id>       Subtask ID(s) to remove in format "parentId.subtaskId" (can be comma-separated, required)\n' +
     '  -c, --convert       Convert the subtask to a standalone task instead of deleting it\n' +
     '  -f, --file <file>   Path to the tasks file (default: "tasks/tasks.json")\n' +
-    '  --skip-generate     Skip regenerating task files\n\n' +
+    '  --generate          Regenerate task files after removing subtask\n\n' +
     chalk.cyan('Examples:') + '\n' +
     '  task-master remove-subtask --id=\'5.2\'\n' +
     '  task-master remove-subtask --id=\'5.2,6.3,7.1\'\n' +

.cursor/rules/taskmaster.mdc

@@ -158,7 +158,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
     *   `details`: `Provide implementation notes or details for the new subtask.` (CLI: `--details <text>`)
     *   `dependencies`: `Specify IDs of other tasks or subtasks, e.g., '15' or '16.1', that must be done before this new subtask.` (CLI: `--dependencies <ids>`)
     *   `status`: `Set the initial status for the new subtask. Default is 'pending'.` (CLI: `-s, --status <status>`)
-    *   `skipGenerate`: `Prevent Taskmaster from automatically regenerating markdown task files after adding the subtask.` (CLI: `--skip-generate`)
+    *   `generate`: `Enable Taskmaster to regenerate markdown task files after adding the subtask.` (CLI: `--generate`)
     *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
     *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
 *   **Usage:** Break down tasks manually or reorganize existing tasks.
@@ -286,7 +286,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **Key Parameters/Options:**
     *   `id`: `Required. The ID(s) of the Taskmaster subtask(s) to remove, e.g., '15.2' or '16.1,16.3'.` (CLI: `-i, --id <id>`)
     *   `convert`: `If used, Taskmaster will turn the subtask into a regular top-level task instead of deleting it.` (CLI: `-c, --convert`)
-    *   `skipGenerate`: `Prevent Taskmaster from automatically regenerating markdown task files after removing the subtask.` (CLI: `--skip-generate`)
+    *   `generate`: `Enable Taskmaster to regenerate markdown task files after removing the subtask.` (CLI: `--generate`)
     *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
     *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
 *   **Usage:** Delete unnecessary subtasks or promote a subtask to a top-level task.

.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)

.env.example

@@ -8,6 +8,7 @@ GROQ_API_KEY=YOUR_GROQ_KEY_HERE
 OPENROUTER_API_KEY=YOUR_OPENROUTER_KEY_HERE
 XAI_API_KEY=YOUR_XAI_KEY_HERE
 AZURE_OPENAI_API_KEY=YOUR_AZURE_KEY_HERE
+OLLAMA_API_KEY=YOUR_OLLAMA_API_KEY_HERE
 
 # Google Vertex AI Configuration
 VERTEX_PROJECT_ID=your-gcp-project-id

.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:
+  workflow_dispatch:
-      - main
+
-      - next
+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:
+  # Fast checks that can run in parallel
-    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') }}
-
   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
+      - name: Install dependencies
-        uses: actions/cache@v4
+        run: npm install --frozen-lockfile --prefer-offline
-        with:
+        timeout-minutes: 5
-          path: node_modules
-          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
 
       - name: Format Check
         run: npm run format-check
         env:
           FORCE_COLOR: 1
 
-  test:
+  typecheck:
-    needs: setup
+    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
+      - name: Install dependencies
-        uses: actions/cache@v4
+        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
+          fetch-depth: 2
-          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
+
+      - 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
-          npx changeset pre enter rc
+          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)
+      - name: Check pre-release mode
-        run: npx changeset pre exit || true
+        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,13 @@ 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

.kiro/hooks/tm-code-change-task-tracker.kiro.hook

@@ -0,0 +1,23 @@
+{
+  "enabled": true,
+  "name": "[TM] Code Change Task Tracker",
+  "description": "Track implementation progress by monitoring code changes",
+  "version": "1",
+  "when": {
+    "type": "fileEdited",
+    "patterns": [
+      "**/*.{js,ts,jsx,tsx,py,go,rs,java,cpp,c,h,hpp,cs,rb,php,swift,kt,scala,clj}",
+      "!**/node_modules/**",
+      "!**/vendor/**",
+      "!**/.git/**",
+      "!**/build/**",
+      "!**/dist/**",
+      "!**/target/**",
+      "!**/__pycache__/**"
+    ]
+  },
+  "then": {
+    "type": "askAgent",
+    "prompt": "I just saved a source code file. Please:\n\n1. Check what task is currently 'in-progress' using 'tm list --status=in-progress'\n2. Look at the file I saved and summarize what was changed (considering the programming language and context)\n3. Update the task's notes with: 'tm update-subtask --id=<task_id> --prompt=\"Implemented: <summary_of_changes> in <file_path>\"'\n4. If the changes seem to complete the task based on its description, ask if I want to mark it as done"
+  }
+}