@e0ipso/ai-task-manager 1.7.1 → 1.8.1

package/README.md

@@ -1,121 +1,55 @@
 # 🤖 AI Task Manager
 
 [![npm version](https://img.shields.io/npm/v/@e0ipso/ai-task-manager.svg)](https://www.npmjs.com/package/@e0ipso/ai-task-manager)
-[![License](https://img.shields.io/badge/License-Proprietary-red.svg)](LICENSE)
+[![License](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 
-AI-powered task management that creates structured workflows within your existing AI subscriptions. Supports Claude Code, Gemini CLI, and Open Code through custom slash commands.
+**AI-powered task management that creates structured workflows within your existing AI subscriptions.**
 
-💰 Unlike projects such as **Plandex**, **Claude Task Master**, and **Conductor Tasks** that require API keys with pay-per-token pricing, **AI Task Manager** works within your existing AI subscription interface. Simply log in to your Claude or Gemini account and use the slash commands - **no API keys or additional costs required**.
+Transform chaotic AI prompts into organized, executable development workflows through custom slash commands for Claude Code, Gemini CLI, and Open Code.
 
-## How It Works
-
-This tool creates custom slash commands (like `/tasks:create-plan`, `/tasks:generate-tasks`) that integrate directly into:
-- **Claude Code**: Works with your Claude Pro/Max subscription via [claude.ai/code](https://claude.ai/code)
-- **Gemini CLI**: Uses your existing Gemini subscription  
-- **Open Code**: Leverages your preferred open-source setup
-
-## ✨ Features
-
-- 🤝 **Multi-Assistant Support**: Configure support for Claude, Gemini, and Open Code
-- 📋 **Template System**: Built-in templates for different project types (basic, development, research)
+## 💰 No Additional Costs
 
+Unlike Plandex, Claude Task Master, and Conductor Tasks that require API keys with pay-per-token pricing, **AI Task Manager works within your existing AI subscriptions** - no API keys or additional costs required.
 
 ## 🚀 Quick Start
 
-### 🏗️ Initialize a New Workspace
-
-The `--assistants` flag is **required** when initializing a workspace. You must specify which coding assistant(s) you want to configure support for.
-
-AI Task Manager supports multiple coding assistants. You **must** specify which assistant(s) to use during initialization using the `--assistants` flag.
-
-🤖 Supported Assistants are
-
-- 🎭 **Claude**: Anthropic's Claude AI assistant
-- 💎 **Gemini**: Google's Gemini AI assistant
-- 📝 **Open Code**: Open source code assistant
-
-The `--destination-directory` flag allows you to specify an alternative directory for the workspace. By default, the workspace is initialized in the current working directory.
-
 ```bash
-# Claude only
+# Initialize for your preferred AI assistant
 npx @e0ipso/ai-task-manager init --assistants claude
-
-# Gemini only
-npx @e0ipso/ai-task-manager init --assistants gemini
-
-# Open Code only
+npx @e0ipso/ai-task-manager init --assistants gemini  
 npx @e0ipso/ai-task-manager init --assistants opencode
 
-# Multiple assistants
-npx @e0ipso/ai-task-manager init --assistants claude,gemini
-npx @e0ipso/ai-task-manager init --assistants claude,opencode
+# Or configure multiple assistants
 npx @e0ipso/ai-task-manager init --assistants claude,gemini,opencode
 ```
 
-If the script detects that any of the folders it needs to create already exist it merge the folder structures, but it will overwrite the files in them.
-
-### 📂 Directory Structure
-
-When you initialize with assistant selection, the following directory structure is created:
-
-```
-project-root/
-├── .ai/
-│   └── task-manager/              # Shared configuration files
-│       ├── plans
-│       ├── TASK_MANAGER.md   # General information to operate the task manager
-│       └── POST_PHASE.md    # Validation gates for phase completion
-├── .claude/                       # Claude files (if selected)
-│   └── commands/                  # Custom slash commands for Claude
-│       └── tasks/
-│           ├── create-plan.md
-│           ├── execute-blueprint.md
-│           └── generate-tasks.md
-├── .gemini/                       # Gemini files (if selected)
-│   └── commands/                  # Custom slash commands for Gemini
-│       └── tasks/
-│           ├── create-plan.toml
-│           ├── execute-blueprint.toml
-│           └── generate-tasks.toml
-├── .opencode/                     # Open Code files (if selected)
-│   └── commands/                  # Custom slash commands for Open Code
-│       └── tasks/
-│           ├── create-plan.md
-│           ├── execute-blueprint.md
-│           └── generate-tasks.md
-└── project files...
-```
-
-## 💡 Suggested Workflow
-
-### 📋 One-time Setup
-
-Review and tweak the `.ai/task-manager/TASK_MANAGER.md` and `.ai/task-manager/config/hooks/POST_PHASE.md`. These files are yours to edit and should reflect your project's tech stack and goals.
+## 📖 Documentation
 
-### 🔄 Day-to-day Workflow
+**For complete setup instructions, features, and workflow guides, visit:**
 
-1. 📝 Create a plan: `/tasks:create-plan Create an authentication workflow for the application using ...`
-2. 💬 Provide additional context if the assistant needs it.
-3. ⚠️ Manually review the plan and make the necessary edits. You might be tempted to skip this step, **do not skip this step**. Find the plan document in `.ai/task-manager/plans/01--authentication-workflow/plan-01--authentication-workflow.md`
-4. 📋 Create the tasks for the plan: `/tasks:generate-tasks 1`
-5. 👀 Review the list of tasks. This step is important to avoid scope creep and ensure the right things are to be built. Again, **do not skip this step**. Find the tasks in the folder `.ai/task-manager/plans/01--authentication-workflow/tasks/`
-6. 🚀 Execute the tasks: `/tasks:execute-blueprint 1`
-7. ✅ Review the implementation and the generated tests.
+### 🌐 **[Documentation Site →](https://mateuaguilo.com/ai-task-manager/)**
 
-## 🔧 Troubleshooting
+The documentation includes:
+- Detailed installation and setup instructions
+- Complete workflow guides with examples
+- Feature overview and capabilities
+- Troubleshooting and best practices
+- Architecture and customization details
 
-<details>
-<summary>🚫 Permission Errors</summary>
+## 💡 Quick Workflow Preview
 
-**Error**: File system permission errors during initialization
+1. **📝 Create a plan**: `/tasks:create-plan Create user authentication system`
+2. **📋 Generate tasks**: `/tasks:generate-tasks 1` 
+3. **🚀 Execute blueprint**: `/tasks:execute-blueprint 1`
 
-**Solutions**:
-- Ensure you have write permissions to the target directory
-- On Unix systems, check directory ownership: `ls -la`
-- Try running with appropriate permissions or in a user-owned directory
+## 🤖 Supported Assistants
 
-</details>
+| Assistant | Interface | Cost Model |
+|-----------|-----------|------------|
+| 🎭 **Claude** | [claude.ai/code](https://claude.ai/code) | Your existing subscription |
+| 💎 **Gemini** | Gemini CLI | Your existing subscription |  
+| 📝 **Open Code** | Open source | Free |
 
 ## 📄 License
 
-⚖️ **Open Source MIT License**
+MIT License - Open source and free to use.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e0ipso/ai-task-manager",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "description": "Task management for AI coding assistants",
   "main": "dist/index.js",
   "bin": {

package/templates/ai-task-manager/config/hooks/POST_ERROR_DETECTION.md

@@ -0,0 +1,48 @@
+# POST_ERROR_DETECTION Hook
+
+This hook provides error handling procedures for task execution failures and validation gate failures.
+
+## Task Execution Error Handling
+
+If task execution fails:
+
+```bash
+# On execution failure, update status to failed
+echo "Task execution failed - updating status..."
+
+TEMP_FILE=$(mktemp)
+awk '
+    /^---$/ {
+        if (++delim == 1) {
+            print
+            next
+        } else if (delim == 2) {
+            print "status: \"failed\""
+            print
+            next
+        }
+    }
+    /^status:/ && delim == 1 {
+        print "status: \"failed\""
+        next
+    }
+    { print }
+' "$TASK_FILE" > "$TEMP_FILE"
+
+mv "$TEMP_FILE" "$TASK_FILE"
+
+echo "Task ${TASK_ID} marked as failed"
+echo "Check the task requirements and try again"
+exit 1
+```
+
+## Validation Gate Failure Handling
+
+#### Validation Gate Failures
+If validation gates fail:
+1. Document which specific validations failed
+2. Identify which tasks may have caused the failure
+3. Generate remediation plan
+4. Re-execute affected tasks after fixes
+5. Re-run validation gates
+6. If errors persist, escalate to the user

package/templates/ai-task-manager/config/hooks/POST_PLAN.md

@@ -0,0 +1,136 @@
+# POST_PLAN Hook
+
+This hook provides validation and update procedures to execute after plan creation, ensuring comprehensive context analysis and proper plan document structuring with dependency visualization.
+
+## Plan Validation and Clarification
+
+#### Step 1: Context Analysis
+Before creating any plan, analyze the user's request for:
+- **Objective**: What is the end goal?
+- **Scope**: What are the boundaries and constraints?
+- **Resources**: What tools, budget, or team are available?
+- **Success Criteria**: How will success be measured?
+- **Dependencies**: What prerequisites or blockers exist?
+- **Technical Requirements**: What technologies or skills are needed?
+
+#### Step 2: Clarification Phase
+If any critical context is missing:
+1. Identify specific gaps in the information provided
+2. Ask targeted follow-up questions grouped by category
+3. Wait for user responses before proceeding to planning
+4. Frame questions clearly with examples when helpful
+5. Be extra cautious. Users miss important context very often. Don't hesitate to ask for clarifications.
+
+Example clarifying questions:
+- "Q: What is your primary goal with [specific aspect]?"
+- "Q: Do you have any existing [resources/code/infrastructure] I should consider?"
+- "Q: What is your timeline for completing this?"
+- "Q: Are there specific constraints I should account for?"
+- "Q: Do you want me to write tests for this?"
+- "Q: Are there other systems, projects, or modules that perform a similar task?"
+
+Try to answer your own questions first by inspecting the codebase, docs, and assistant documents like CLAUDE.md, GEMINI.md, AGENTS.md ...
+
+## Update the plan document
+
+After creating all tasks with their dependencies, update the original plan document with two critical sections: a task dependency visualization and a phase-based execution blueprint.
+
+### Section 1: Dependency Visualization
+
+If any tasks have dependencies, create a Mermaid diagram showing the dependency graph:
+
+```mermaid
+graph TD
+    001[Task 001: Database Schema] --> 002[Task 002: API Endpoints]
+    001 --> 003[Task 003: Data Models]
+    002 --> 004[Task 004: Frontend Integration]
+    003 --> 004
+```
+
+Note: Ensure the graph is acyclic (no circular dependencies).
+
+### Section 2: Phase-Based Execution Blueprint
+
+#### Core Concept
+The execution blueprint organizes tasks into sequential phases where:
+- **Within a phase**: All tasks execute in parallel
+- **Between phases**: Execution is strictly sequential
+- **Phase progression**: Requires all tasks in current phase to complete AND validation gates to pass
+
+#### Phase Definition Rules
+1. **Phase 1**: Contains all tasks with zero dependencies
+2. **Phase N**: Contains tasks whose dependencies are ALL satisfied by tasks in phases 1 through N-1
+3. **Parallelism Priority**: Maximize the number of tasks that can run simultaneously in each phase
+4. **Completeness**: Every task must be assigned to exactly one phase
+
+#### Blueprint Structure
+
+```markdown
+## Execution Blueprint
+
+**Validation Gates:**
+- Reference: `@.ai/task-manager/config/hooks/POST_PHASE.md`
+
+### Phase 1: [Descriptive Phase Name]
+**Parallel Tasks:**
+- Task 001: [Description]
+- Task 005: [Description]
+- Task 009: [Description]
+
+### Phase 2: [Descriptive Phase Name]
+**Parallel Tasks:**
+- Task 002: [Description] (depends on: 001)
+- Task 003: [Description] (depends on: 001)
+- Task 006: [Description] (depends on: 005)
+
+[Continue for all phases...]
+
+### Post-phase Actions
+
+### Execution Summary
+- Total Phases: X
+- Total Tasks: Y
+- Maximum Parallelism: Z tasks (in Phase N)
+- Critical Path Length: X phases
+```
+
+### Validation Requirements
+
+#### Phase Transition Rules
+1. All tasks in the current phase must have status: "completed"
+2. All validation gates defined in `@.ai/task-manager/config/hooks/POST_PHASE.md` for the current phase must pass
+3. No task in a future phase can begin until these conditions are met
+
+#### Blueprint Verification
+Before finalizing, ensure:
+- [ ] Every task appears in exactly one phase
+- [ ] No task appears in a phase before all its dependencies
+- [ ] Phase 1 contains only tasks with no dependencies
+- [ ] Each phase maximizes parallel execution opportunities
+- [ ] All phases reference their validation gates
+- [ ] The execution summary accurately reflects the blueprint
+
+### Important Notes
+
+#### Parallel Execution
+- Tasks within a phase have no interdependencies and can run simultaneously
+- This enables efficient resource utilization and faster completion
+- AI agents can be assigned to multiple tasks within the same phase
+
+#### Sequential Phases
+- Phases execute in strict numerical order
+- Phase N+1 cannot begin until Phase N is fully complete and validated
+- This ensures dependency integrity and systematic progress
+-
+
+#### Validation Gates
+- Each phase has associated validation criteria defined externally
+- Gates ensure quality and correctness before progression
+- Failed validations require task remediation before phase completion
+
+### Error Handling
+
+If dependency analysis reveals issues:
+- **Circular dependencies**: Document the cycle and mark affected tasks for review
+- **Orphaned tasks**: Tasks that cannot be scheduled due to missing dependencies
+- **Ambiguous dependencies**: Note assumptions made and flag for clarification

package/templates/ai-task-manager/config/hooks/PRE_PHASE.md

@@ -0,0 +1,28 @@
+# PRE_PHASE Hook
+
+This hook contains the phase preparation logic that should be executed before starting any phase execution.
+
+## Phase Pre-Execution
+
+Before starting execution check if you are in the `main` branch. If so, create a git branch to work on this blueprint use the plan name for the branch name.
+
+If there are unstaged changes in the `main` branch, do not create a feature branch.
+
+## Phase Execution Workflow
+
+1. **Phase Initialization**
+    - Identify current phase from the execution blueprint
+    - List all tasks scheduled for parallel execution in this phase
+    - **Validate Task Dependencies**: For each task in the current phase, use the dependency checking script:
+        ```bash
+        # For each task in current phase
+        for TASK_ID in $PHASE_TASKS; do
+            if ! node .ai/task-manager/config/scripts/check-task-dependencies.js "$1" "$TASK_ID"; then
+                echo "ERROR: Task $TASK_ID has unresolved dependencies - cannot proceed with phase execution"
+                echo "Please resolve dependencies before continuing with blueprint execution"
+                exit 1
+            fi
+        done
+        ```
+    - Confirm no tasks are marked "needs-clarification"
+    - If any phases are marked as completed, verify they are actually completed and continue from the next phase.

package/templates/ai-task-manager/config/hooks/PRE_TASK_ASSIGNMENT.md

@@ -0,0 +1,69 @@
+# Pre-Task Assignment Hook
+
+This hook executes before task assignment to determine the most appropriate agent for each task based on skill requirements and available sub-agents.
+
+## Agent Selection and Task Assignment
+
+- For each task in the current phase:
+    - Read task frontmatter to extract the `skills` property (array of technical skills)
+    - Analyze task requirements and technical domain from description
+    - Match task skills against available sub-agent capabilities
+    - Select the most appropriate sub-agent (if any are available). If no sub-agent is appropriate, use the general-purpose one.
+    - Consider task-specific requirements from the task document
+
+## Available Sub-Agents
+Analyze the sub-agents available in your current assistant's agents directory. If none are available
+or the available ones do not match the task's requirements, then use a generic
+agent.
+
+## Matching Criteria
+Select agents based on:
+1. **Primary skill match**: Task technical requirements from the `skills` array in task frontmatter
+2. **Domain expertise**: Specific frameworks or libraries mentioned in task descriptions
+3. **Task complexity**: Senior vs. junior agent capabilities
+4. **Resource efficiency**: Avoid over-provisioning for simple tasks
+
+## Skills Extraction and Agent Detection
+
+Read task skills and select appropriate task-specific agent:
+
+```bash
+# Extract skills from task frontmatter
+TASK_SKILLS=$(awk '
+    /^---$/ { if (++delim == 2) exit }
+    /^skills:/ {
+        in_skills = 1
+        # Check if skills are on the same line
+        if (match($0, /\[.*\]/)) {
+            gsub(/^skills:[ \t]*\[/, "")
+            gsub(/\].*$/, "")
+            gsub(/[ \t]/, "")
+            print
+            in_skills = 0
+        }
+        next
+    }
+    in_skills && /^[^ ]/ { in_skills = 0 }
+    in_skills && /^[ \t]*-/ {
+        gsub(/^[ \t]*-[ \t]*/, "")
+        gsub(/^"/, ""); gsub(/"$/, "")
+        print
+    }
+' "$TASK_FILE" | tr ',' '\n' | sed 's/^[ \t]*//;s/[ \t]*$//' | grep -v '^$')
+
+echo "Task skills required: $TASK_SKILLS"
+
+# Check for available sub-agents across assistant directories
+AGENT_FOUND=false
+for assistant_dir in .claude .gemini .opencode; do
+    if [ -d "$assistant_dir/agents" ] && [ -n "$(ls $assistant_dir/agents 2>/dev/null)" ]; then
+        echo "Available sub-agents detected in $assistant_dir - will match to task requirements"
+        AGENT_FOUND=true
+        break
+    fi
+done
+
+if [ "$AGENT_FOUND" = false ]; then
+    echo "Using general-purpose agent for task execution"
+fi
+```

package/templates/assistant/commands/tasks/create-plan.md

@@ -29,32 +29,7 @@ Use your internal Todo task tool to track the plan generation. Example:
 - [ ] Plan generation: Risk Considerations
 - [ ] Plan generation: Success Metrics
 
-#### Step 1: Context Analysis
-Before creating any plan, analyze the user's request for:
-- **Objective**: What is the end goal?
-- **Scope**: What are the boundaries and constraints?
-- **Resources**: What tools, budget, or team are available?
-- **Success Criteria**: How will success be measured?
-- **Dependencies**: What prerequisites or blockers exist?
-- **Technical Requirements**: What technologies or skills are needed?
-
-#### Step 2: Clarification Phase
-If any critical context is missing:
-1. Identify specific gaps in the information provided
-2. Ask targeted follow-up questions grouped by category
-3. Wait for user responses before proceeding to planning
-4. Frame questions clearly with examples when helpful
-5. Be extra cautious. Users miss important context very often. Don't hesitate to ask for clarifications.
-
-Example clarifying questions:
-- "Q: What is your primary goal with [specific aspect]?"
-- "Q: Do you have any existing [resources/code/infrastructure] I should consider?"
-- "Q: What is your timeline for completing this?"
-- "Q: Are there specific constraints I should account for?"
-- "Q: Do you want me to write tests for this?"
-- "Q: Are there other systems, projects, or modules that perform a similar task?"
-
-Try to answer your own questions first by inspecting the codebase, docs, and assistant documents like CLAUDE.md, GEMINI.md, AGENTS.md ...
+Read and execute @.ai/task-manager/config/hooks/POST_PLAN.md
 
 #### Step 3: Plan Generation
 Only after confirming sufficient context, create a plan that includes:

package/templates/assistant/commands/tasks/execute-blueprint.md

@@ -37,36 +37,16 @@ Use your internal Todo task tool to track the execution of all phases, and the f
 
 ### Phase Pre-Execution
 
-Before starting execution check if you are in the `main` branch. If so, create a git branch to work on this blueprint use the plan name for the branch name.
-
-If there are unstaged changes in the `main` branch, do not create a feature branch.
+Read and execute @.ai/task-manager/config/hooks/PRE_PHASE.md
 
 ### Phase Execution Workflow
 
 1. **Phase Initialization**
     - Identify current phase from the execution blueprint
     - List all tasks scheduled for parallel execution in this phase
-    - **Validate Task Dependencies**: For each task in the current phase, use the dependency checking script:
-        ```bash
-        # For each task in current phase
-        for TASK_ID in $PHASE_TASKS; do
-            if ! node .ai/task-manager/config/scripts/check-task-dependencies.js "$1" "$TASK_ID"; then
-                echo "ERROR: Task $TASK_ID has unresolved dependencies - cannot proceed with phase execution"
-                echo "Please resolve dependencies before continuing with blueprint execution"
-                exit 1
-            fi
-        done
-        ```
-    - Confirm no tasks are marked "needs-clarification"
-    - If any phases are marked as completed, verify they are actually completed and continue from the next phase.
 
 2. **Agent Selection and Task Assignment**
-    - For each task in the current phase:
-        - Read task frontmatter to extract the `skills` property (array of technical skills)
-        - Analyze task requirements and technical domain from description
-        - Match task skills against available sub-agent capabilities
-        - Select the most appropriate sub-agent (if any are available). If no sub-agent is appropriate, use the general-purpose one.
-        - Consider task-specific requirements from the task document
+Read and execute @.ai/task-manager/config/hooks/PRE_TASK_ASSIGNMENT.md
 
 3. **Parallel Execution**
     - Deploy all selected agents simultaneously using your internal Task tool
@@ -90,20 +70,6 @@ If there are unstaged changes in the `main` branch, do not create a feature bran
     - Initialize next phase
     - Repeat process until all phases are complete
 
-### Agent Selection Guidelines
-
-#### Available Sub-Agents
-Analyze the sub-agents available in your current assistant's agents directory. If none are available
-or the available ones do not match the task's requirements, then use a generic
-agent.
-
-#### Matching Criteria
-Select agents based on:
-1. **Primary skill match**: Task technical requirements from the `skills` array in task frontmatter
-2. **Domain expertise**: Specific frameworks or libraries mentioned in task descriptions
-3. **Task complexity**: Senior vs. junior agent capabilities
-4. **Resource efficiency**: Avoid over-provisioning for simple tasks
-
 ### Execution Monitoring
 
 #### Progress Tracking
@@ -124,13 +90,7 @@ Valid status transitions:
 ### Error Handling
 
 #### Validation Gate Failures
-If validation gates fail:
-1. Document which specific validations failed
-2. Identify which tasks may have caused the failure
-3. Generate remediation plan
-4. Re-execute affected tasks after fixes
-5. Re-run validation gates
-6. If errors persist, escalate to the user
+Read and execute @.ai/task-manager/config/hooks/POST_ERROR_DETECTION.md
 
 ### Output Requirements
 

package/templates/assistant/commands/tasks/execute-task.md

@@ -150,44 +150,7 @@ echo "✓ All dependencies resolved - proceeding with execution"
 Read task skills and select appropriate task-specific agent:
 
 ```bash
-# Extract skills from task frontmatter
-TASK_SKILLS=$(awk '
-    /^---$/ { if (++delim == 2) exit }
-    /^skills:/ {
-        in_skills = 1
-        # Check if skills are on the same line
-        if (match($0, /\[.*\]/)) {
-            gsub(/^skills:[ \t]*\[/, "")
-            gsub(/\].*$/, "")
-            gsub(/[ \t]/, "")
-            print
-            in_skills = 0
-        }
-        next
-    }
-    in_skills && /^[^ ]/ { in_skills = 0 }
-    in_skills && /^[ \t]*-/ {
-        gsub(/^[ \t]*-[ \t]*/, "")
-        gsub(/^"/, ""); gsub(/"$/, "")
-        print
-    }
-' "$TASK_FILE" | tr ',' '\n' | sed 's/^[ \t]*//;s/[ \t]*$//' | grep -v '^$')
-
-echo "Task skills required: $TASK_SKILLS"
-
-# Check for available sub-agents across assistant directories
-AGENT_FOUND=false
-for assistant_dir in .claude .gemini .opencode; do
-    if [ -d "$assistant_dir/agents" ] && [ -n "$(ls $assistant_dir/agents 2>/dev/null)" ]; then
-        echo "Available sub-agents detected in $assistant_dir - will match to task requirements"
-        AGENT_FOUND=true
-        break
-    fi
-done
-
-if [ "$AGENT_FOUND" = false ]; then
-    echo "Using general-purpose agent for task execution"
-fi
+Read and execute @.ai/task-manager/config/hooks/PRE_TASK_ASSIGNMENT.md
 ```
 
 ### 6. Status Update to In-Progress
@@ -271,37 +234,7 @@ echo "You can now execute dependent tasks or continue with the full blueprint ex
 
 ## Error Handling
 
-If task execution fails:
-
-```bash
-# On execution failure, update status to failed
-echo "Task execution failed - updating status..."
-
-TEMP_FILE=$(mktemp)
-awk '
-    /^---$/ {
-        if (++delim == 1) {
-            print
-            next
-        } else if (delim == 2) {
-            print "status: \"failed\""
-            print
-            next
-        }
-    }
-    /^status:/ && delim == 1 {
-        print "status: \"failed\""
-        next
-    }
-    { print }
-' "$TASK_FILE" > "$TEMP_FILE"
-
-mv "$TEMP_FILE" "$TASK_FILE"
-
-echo "Task ${TASK_ID} marked as failed"
-echo "Check the task requirements and try again"
-exit 1
-```
+Read and execute @.ai/task-manager/config/hooks/POST_ERROR_DETECTION.md
 
 ## Usage Examples
 

package/templates/assistant/commands/tasks/generate-tasks.md

@@ -348,106 +348,4 @@ If the plan lacks sufficient detail:
 - Create placeholder tasks marked with `status: "needs-clarification"`
 - Document assumptions made
 
-## Update the plan document
-
-After creating all tasks with their dependencies, update the original plan document with two critical sections: a task dependency visualization and a phase-based execution blueprint.
-
-### Section 1: Dependency Visualization
-
-If any tasks have dependencies, create a Mermaid diagram showing the dependency graph:
-
-```mermaid
-graph TD
-    001[Task 001: Database Schema] --> 002[Task 002: API Endpoints]
-    001 --> 003[Task 003: Data Models]
-    002 --> 004[Task 004: Frontend Integration]
-    003 --> 004
-```
-
-Note: Ensure the graph is acyclic (no circular dependencies).
-
-### Section 2: Phase-Based Execution Blueprint
-
-#### Core Concept
-The execution blueprint organizes tasks into sequential phases where:
-- **Within a phase**: All tasks execute in parallel
-- **Between phases**: Execution is strictly sequential
-- **Phase progression**: Requires all tasks in current phase to complete AND validation gates to pass
-
-#### Phase Definition Rules
-1. **Phase 1**: Contains all tasks with zero dependencies
-2. **Phase N**: Contains tasks whose dependencies are ALL satisfied by tasks in phases 1 through N-1
-3. **Parallelism Priority**: Maximize the number of tasks that can run simultaneously in each phase
-4. **Completeness**: Every task must be assigned to exactly one phase
-
-#### Blueprint Structure
-
-```markdown
-## Execution Blueprint
-
-**Validation Gates:**
-- Reference: `@.ai/task-manager/config/hooks/POST_PHASE.md`
-
-### Phase 1: [Descriptive Phase Name]
-**Parallel Tasks:**
-- Task 001: [Description]
-- Task 005: [Description]
-- Task 009: [Description]
-
-### Phase 2: [Descriptive Phase Name]
-**Parallel Tasks:**
-- Task 002: [Description] (depends on: 001)
-- Task 003: [Description] (depends on: 001)
-- Task 006: [Description] (depends on: 005)
-
-[Continue for all phases...]
-
-### Post-phase Actions
-
-### Execution Summary
-- Total Phases: X
-- Total Tasks: Y
-- Maximum Parallelism: Z tasks (in Phase N)
-- Critical Path Length: X phases
-```
-
-### Validation Requirements
-
-#### Phase Transition Rules
-1. All tasks in the current phase must have status: "completed"
-2. All validation gates defined in `@.ai/task-manager/config/hooks/POST_PHASE.md` for the current phase must pass
-3. No task in a future phase can begin until these conditions are met
-
-#### Blueprint Verification
-Before finalizing, ensure:
-- [ ] Every task appears in exactly one phase
-- [ ] No task appears in a phase before all its dependencies
-- [ ] Phase 1 contains only tasks with no dependencies
-- [ ] Each phase maximizes parallel execution opportunities
-- [ ] All phases reference their validation gates
-- [ ] The execution summary accurately reflects the blueprint
-
-### Important Notes
-
-#### Parallel Execution
-- Tasks within a phase have no interdependencies and can run simultaneously
-- This enables efficient resource utilization and faster completion
-- AI agents can be assigned to multiple tasks within the same phase
-
-#### Sequential Phases
-- Phases execute in strict numerical order
-- Phase N+1 cannot begin until Phase N is fully complete and validated
-- This ensures dependency integrity and systematic progress
--
-
-#### Validation Gates
-- Each phase has associated validation criteria defined externally
-- Gates ensure quality and correctness before progression
-- Failed validations require task remediation before phase completion
-
-### Error Handling
-
-If dependency analysis reveals issues:
-- **Circular dependencies**: Document the cycle and mark affected tasks for review
-- **Orphaned tasks**: Tasks that cannot be scheduled due to missing dependencies
-- **Ambiguous dependencies**: Note assumptions made and flag for clarification
+Read and execute @.ai/task-manager/config/hooks/POST_PLAN.md