chore: apply requested changes

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

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

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

.changeset/config.json

@@ -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/fuzzy-words-count.md

@@ -0,0 +1,8 @@
+---
+"task-master-ai": patch
+---
+
+Fix scope-up/down prompts to include all required fields for better AI model compatibility
+
+- Added missing `priority` field to scope adjustment prompts to prevent validation errors with Claude-code and other models
+- Ensures generated JSON includes all fields required by the schema

.changeset/mean-planes-wave.md

@@ -1,47 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add Claude Code plugin with marketplace distribution
-
-This release introduces official Claude Code plugin support, marking the evolution from legacy `.claude` directory copying to a modern plugin-based architecture.
-
-## 🎉 New: Claude Code Plugin
-
-Task Master AI commands and agents are now distributed as a proper Claude Code plugin:
-
-- **49 slash commands** with clean naming (`/taskmaster:command-name`)
-- **3 specialized AI agents** (task-orchestrator, task-executor, task-checker)
-- **MCP server integration** for deep Claude Code integration
-
-**Installation:**
-
-```bash
-/plugin marketplace add eyaltoledano/claude-task-master
-/plugin install taskmaster@taskmaster
-```
-
-### The `rules add claude` command no longer copies commands and agents to `.claude/commands/` and `.claude/agents/`. Instead, it now
-
-- Shows plugin installation instructions
-- Only manages CLAUDE.md imports for agent instructions
-- Directs users to install the official plugin
-
-**Migration for Existing Users:**
-
-If you previously used `rules add claude`:
-
-1. The old commands in `.claude/commands/` will continue to work but won't receive updates
-2. Install the plugin for the latest features: `/plugin install taskmaster@taskmaster`
-3. remove old `.claude/commands/` and `.claude/agents/` directories
-
-**Why This Change?**
-
-Claude Code plugins provide:
-
-- ✅ Automatic updates when we release new features
-- ✅ Better command organization and naming
-- ✅ Seamless integration with Claude Code
-- ✅ No manual file copying or management
-
-The plugin system is the future of Task Master AI integration with Claude Code!

.changeset/nice-ways-hope.md

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

.changeset/plain-falcons-serve.md

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

.changeset/pre.json

@@ -1,21 +0,0 @@
-{
-  "mode": "exit",
-  "tag": "rc",
-  "initialVersions": {
-    "task-master-ai": "0.28.0",
-    "@tm/cli": "",
-    "docs": "0.0.5",
-    "extension": "0.25.5",
-    "@tm/ai-sdk-provider-grok-cli": "",
-    "@tm/build-config": "",
-    "@tm/claude-code-plugin": "0.0.1",
-    "@tm/core": ""
-  },
-  "changesets": [
-    "auto-update-changelog-highlights",
-    "mean-planes-wave",
-    "nice-ways-hope",
-    "plain-falcons-serve",
-    "smart-owls-relax"
-  ]
-}

.changeset/silent-bushes-grow.md

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

.changeset/smart-owls-relax.md

@@ -1,16 +0,0 @@
----
-"task-master-ai": minor
----
-
-Enhance `expand_all` to intelligently use complexity analysis recommendations when expanding tasks. 
-
-The expand-all operation now automatically leverages recommendations from `analyze-complexity` to determine optimal subtask counts for each task, resulting in more accurate and context-aware task breakdowns.
-
-Key improvements:
-- Automatic integration with complexity analysis reports
-- Tag-aware complexity report path resolution
-- Intelligent subtask count determination based on task complexity
-- Falls back to defaults when complexity analysis is unavailable
-- Enhanced logging for better visibility into expansion decisions
-
-When you run `task-master expand --all` after `task-master analyze-complexity`, Task Master now uses the recommended subtask counts from the complexity analysis instead of applying uniform defaults, ensuring each task is broken down according to its actual complexity.

.changeset/tender-trams-refuse.md

@@ -0,0 +1,8 @@
+---
+"task-master-ai": patch
+---
+
+Fix MCP scope-up/down tools not finding tasks
+
+- Fixed task ID parsing in MCP layer - now correctly converts string IDs to numbers
+- scope_up_task and scope_down_task MCP tools now work properly

.changeset/vast-sites-leave.md

@@ -0,0 +1,11 @@
+---
+"task-master-ai": patch
+---
+
+Improve AI provider compatibility for JSON generation
+
+- Fixed schema compatibility issues between Perplexity and OpenAI o3 models
+- Removed nullable/default modifiers from Zod schemas for broader compatibility
+- Added automatic JSON repair for malformed AI responses (handles cases like missing array values)
+- Perplexity now uses JSON mode for more reliable structured output
+- Post-processing handles default values separately from schema validation

.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",

.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/release.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+set -e
+
+echo "🚀 Starting release process..."
+
+# Double-check we're not in pre-release mode (safety net)
+if [ -f .changeset/pre.json ]; then
+  echo "⚠️  Warning: pre.json still exists. Removing it..."
+  rm -f .changeset/pre.json
+fi
+
+# Check if the extension version has changed and tag it
+# This prevents changeset from trying to publish the private package
+node .github/scripts/tag-extension.mjs
+
+# Run changeset publish for npm packages
+npx changeset publish
+
+echo "✅ Release process completed!"
+
+# The extension tag (if created) will trigger the extension-release workflow

.github/scripts/tag-extension.mjs

@@ -1,13 +1,33 @@
 #!/usr/bin/env node
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { findRootDir, createAndPushTag } from './utils.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Find the root directory by looking for package.json
+function findRootDir(startDir) {
+	let currentDir = resolve(startDir);
+	while (currentDir !== '/') {
+		if (existsSync(join(currentDir, 'package.json'))) {
+			// Verify it's the root package.json by checking for expected fields
+			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');
+}
+
 const rootDir = findRootDir(__dirname);
 
 // Read the extension's package.json
@@ -23,11 +43,95 @@ try {
 	process.exit(1);
 }
 
+// Read root package.json for repository info
+const rootPkgPath = join(rootDir, 'package.json');
+let rootPkg;
+try {
+	const rootPkgContent = readFileSync(rootPkgPath, 'utf8');
+	rootPkg = JSON.parse(rootPkgContent);
+} catch (error) {
+	console.error('Failed to read root 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');
+assert(rootPkg.repository, 'root package.json must have a repository field');
 
 const tag = `${pkg.name}@${pkg.version}`;
 
-// Create and push the tag if it doesn't exist
-createAndPushTag(tag);
+// Get repository URL from root package.json
+// Get repository URL and clean it up for git ls-remote
+let repoUrl = rootPkg.repository.url || rootPkg.repository;
+if (typeof repoUrl === 'string') {
+	// Convert git+https://github.com/... to https://github.com/...
+	repoUrl = repoUrl.replace(/^git\+/, '');
+	// Ensure it ends with .git for proper remote access
+	if (!repoUrl.endsWith('.git')) {
+		repoUrl += '.git';
+	}
+}
+
+console.log(`Checking remote repository: ${repoUrl} for tag: ${tag}`);
+
+let gitResult = spawnSync('git', ['ls-remote', repoUrl, tag], {
+	encoding: 'utf8',
+	env: { ...process.env }
+});
+
+if (gitResult.status !== 0) {
+	console.error('Git ls-remote failed:');
+	console.error('Exit code:', gitResult.status);
+	console.error('Error:', gitResult.error);
+	console.error('Stderr:', gitResult.stderr);
+	console.error('Command:', `git ls-remote ${repoUrl} ${tag}`);
+
+	// For CI environments, try using origin instead of the full URL
+	if (process.env.CI) {
+		console.log('Retrying with origin remote...');
+		gitResult = spawnSync('git', ['ls-remote', 'origin', tag], {
+			encoding: 'utf8'
+		});
+
+		if (gitResult.status !== 0) {
+			throw new Error(
+				`Failed to check remote for tag ${tag}. Exit code: ${gitResult.status}`
+			);
+		}
+	} else {
+		throw new Error(
+			`Failed to check remote for tag ${tag}. Exit code: ${gitResult.status}`
+		);
+	}
+}
+
+const exists = String(gitResult.stdout).trim() !== '';
+
+if (!exists) {
+	console.log(`Creating new extension tag: ${tag}`);
+
+	// Create the tag
+	const tagResult = spawnSync('git', ['tag', tag]);
+	if (tagResult.status !== 0) {
+		console.error(
+			'Failed to create tag:',
+			tagResult.error || tagResult.stderr.toString()
+		);
+		process.exit(1);
+	}
+
+	// Push the tag
+	const pushResult = spawnSync('git', ['push', 'origin', tag]);
+	if (pushResult.status !== 0) {
+		console.error(
+			'Failed to push tag:',
+			pushResult.error || pushResult.stderr.toString()
+		);
+		process.exit(1);
+	}
+
+	console.log(`✅ Successfully created and pushed tag: ${tag}`);
+} else {
+	console.log(`Extension tag already exists: ${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

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

.github/workflows/extension-release.yml

@@ -31,7 +31,8 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-node-
 
-      - name: Install Monorepo Dependencies
+      - name: Install Extension Dependencies
+        working-directory: apps/extension
         run: npm ci
         timeout-minutes: 5
 
@@ -88,6 +89,32 @@ jobs:
           OVSX_PAT: ${{ secrets.OVSX_PAT }}
           FORCE_COLOR: 1
 
+      - name: Create GitHub Release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref_name }}
+          release_name: Extension ${{ github.ref_name }}
+          body: |
+            VS Code Extension Release ${{ github.ref_name }}
+            
+            **Marketplaces:**
+            - [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=Hamster.task-master-hamster)
+            - [Open VSX Registry](https://open-vsx.org/extension/Hamster/task-master-hamster)
+          draft: false
+          prerelease: false
+
+      - name: Upload VSIX to Release
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: apps/extension/vsix-build/${{ steps.vsix-info.outputs.vsix-filename }}
+          asset_name: ${{ steps.vsix-info.outputs.vsix-filename }}
+          asset_content_type: application/zip
+
       - name: Upload Build Artifacts
         uses: actions/upload-artifact@v4
         with:

.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

@@ -2,18 +2,24 @@ name: Pre-Release (RC)
 
 on:
   workflow_dispatch: # Allows manual triggering from GitHub UI/API
+    inputs:
+      branch:
+        description: 'Branch to create pre-release from (e.g., next, develop)'
+        required: false
+        default: 'next'
+        type: string
 
 concurrency: pre-release-${{ github.ref_name }}
 jobs:
   rc:
     runs-on: ubuntu-latest
     # Only allow pre-releases on non-main branches
-    if: github.ref != 'refs/heads/main'
-    environment: extension-release
+    if: github.ref != 'refs/heads/main' && inputs.branch != 'main'
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          ref: ${{ inputs.branch || github.ref }}
 
       - uses: actions/setup-node@v4
         with:
@@ -36,26 +42,9 @@ jobs:
 
       - name: Enter RC mode (if not already in 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..."
+          # ensure we’re in the right pre-mode (tag "rc")
+          if [ ! -f .changeset/pre.json ] \
+            || [ "$(jq -r '.tag' .changeset/pre.json 2>/dev/null || echo '')" != "rc" ]; then
             npx changeset pre enter rc
           fi
 
@@ -65,24 +54,10 @@ 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 }}
@@ -91,5 +66,5 @@ jobs:
         uses: actions-js/push@master
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          branch: ${{ github.ref }}
+          branch: ${{ inputs.branch || github.ref_name }}
           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

@@ -22,7 +22,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: "npm"
+          cache: 'npm'
 
       - name: Cache node_modules
         uses: actions/cache@v4
@@ -39,21 +39,30 @@ jobs:
         timeout-minutes: 2
 
       - name: Check pre-release mode
-        run: node ./.github/scripts/check-pre-release-mode.mjs "main"
+        run: |
+          set -euo pipefail
+          echo "🔍 Checking pre-release mode status..."
+          if [[ -f .changeset/pre.json ]]; then
+            echo "❌ ERROR: Main branch is in pre-release mode!"
+            echo ""
+            echo "Pre-release mode should only be used on feature branches, not main."
+            echo ""
+            echo "To fix this, run the following commands locally:"
+            echo "  npx changeset pre exit"
+            echo "  git add -u"
+            echo "  git commit -m 'chore: exit pre-release mode'"
+            echo "  git push origin main"
+            echo ""
+            echo "Then re-run this workflow."
+            exit 1
+          fi
 
-      - 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 }}
+          echo "✅ Not in pre-release mode - proceeding with release"
 
       - name: Create Release Pull Request or Publish to npm
         uses: changesets/action@v1
         with:
-          publish: node ./.github/scripts/release.mjs
+          publish: ./.github/scripts/release.sh
         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

@@ -93,7 +93,4 @@ dev-debug.log
 apps/extension/.vscode-test/
 
 # apps/extension
-apps/extension/vsix-build/
-
-# turbo
-.turbo
+apps/extension/vsix-build/

.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",

.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"]
-}

.nvmrc

@@ -1 +1 @@
-22
+22 

.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/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';
-```

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

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

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

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

.taskmaster/state.json

@@ -1,6 +1,6 @@
 {
 	"currentTag": "master",
-	"lastSwitched": "2025-09-12T22:25:27.535Z",
+	"lastSwitched": "2025-08-01T14:09:25.838Z",
 	"branchTagMapping": {
 		"v017-adds": "v017-adds",
 		"next": "next"

.taskmaster/tasks/task_001_tm-start.txt

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

.taskmaster/tasks/task_002_tm-start.txt

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

.taskmaster/tasks/task_003_tm-start.txt

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