feat: improve PR and add changeset

- Introduced multiple Kiro hooks to automate task management workflows, including:
  - Code Change Task Tracker
  - Complexity Analyzer
  - Daily Standup Assistant
  - Git Commit Task Linker
  - Import Cleanup on Delete
  - New File Boilerplate
  - PR Readiness Checker
  - Task Dependency Auto-Progression
  - Test Success Task Completer
- Added .mcp.json configuration for Taskmaster AI integration.
- Updated development workflow documentation to reflect new hook-driven processes and best practices.

This commit enhances the automation capabilities of Taskmaster, streamlining task management and improving developer efficiency.

.changeset/config.json

@@ -2,16 +2,13 @@
   "$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",
-  "ignore": [
-    "docs",
-    "@tm/claude-code-plugin"
-  ]
+  "updateInternalDependencies": "patch",
+  "ignore": []
 }

.changeset/dirty-hairs-know.md

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

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

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

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

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

.changeset/fresh-bugs-squashed.md

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

.changeset/happy-sites-stay.md

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

.changeset/light-owls-stay.md

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

.changeset/metal-rocks-help.md

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

.changeset/open-tips-notice.md

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

.changeset/orange-pots-add.md

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

.changeset/swift-otters-argue.md

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

.claude-plugin/marketplace.json

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

.claude/commands/dedupe.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.claude/commands/tm/help.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.cursor/mcp.json

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

.cursor/rules/test_workflow.mdc

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

.github/PULL_REQUEST_TEMPLATE.md

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

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

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

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

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

@@ -1,259 +0,0 @@
-#!/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

@@ -1,178 +0,0 @@
-#!/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

@@ -1,102 +0,0 @@
-#!/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

@@ -1,157 +0,0 @@
-#!/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

@@ -1,30 +0,0 @@
-#!/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

@@ -1,33 +0,0 @@
-#!/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

@@ -1,88 +0,0 @@
-#!/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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,108 +0,0 @@
-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,13 +87,3 @@ 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/settings/mcp.json

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

.kiro/steering/test.md

@@ -0,0 +1,3 @@
+Testing rules that you can help me improve to see how it works<!------------------------------------------------------------------------------------
+Add Rules to this file or a short description and have Kiro refine them for you:  
+------------------------------------------------------------------------------------->

.manypkg.json

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

.taskmaster/CLAUDE.md

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

.taskmaster/config.json

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

.taskmaster/docs/MIGRATION-ROADMAP.md

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

.taskmaster/docs/prd-tm-start.txt

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

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

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

.taskmaster/docs/test-prd.txt

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

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

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