@e0ipso/ai-task-manager 1.2.0 → 1.3.0

package/templates/ai-task-manager/config/scripts/check-task-dependencies.sh

@@ -0,0 +1,185 @@
+#!/bin/bash
+
+# Script: check-task-dependencies.sh
+# Purpose: Check if a task has all of its dependencies resolved (completed)
+# Usage: ./check-task-dependencies.sh <plan-id> <task-id>
+# Returns: 0 if all dependencies are resolved, 1 if not
+
+set -e
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_error() {
+    echo -e "${RED}ERROR: $1${NC}" >&2
+}
+
+print_success() {
+    echo -e "${GREEN}✓ $1${NC}"
+}
+
+print_warning() {
+    echo -e "${YELLOW}⚠ $1${NC}"
+}
+
+print_info() {
+    echo -e "$1"
+}
+
+# Check arguments
+if [ $# -ne 2 ]; then
+    print_error "Invalid number of arguments"
+    echo "Usage: $0 <plan-id> <task-id>"
+    echo "Example: $0 16 03"
+    exit 1
+fi
+
+PLAN_ID="$1"
+TASK_ID="$2"
+
+# Find the plan directory
+PLAN_DIR=$(find .ai/task-manager/{plans,archive} -type d -name "${PLAN_ID}--*" 2>/dev/null | head -1)
+
+if [ -z "$PLAN_DIR" ]; then
+    print_error "Plan with ID ${PLAN_ID} not found"
+    exit 1
+fi
+
+print_info "Found plan directory: ${PLAN_DIR}"
+
+# Construct task file path
+# Handle both padded (01, 02) and unpadded (1, 2) task IDs
+TASK_FILE=""
+if [ -f "${PLAN_DIR}/tasks/${TASK_ID}--"*.md ]; then
+    TASK_FILE=$(ls "${PLAN_DIR}/tasks/${TASK_ID}--"*.md 2>/dev/null | head -1)
+elif [ -f "${PLAN_DIR}/tasks/0${TASK_ID}--"*.md ]; then
+    # Try with zero-padding if direct match fails
+    TASK_FILE=$(ls "${PLAN_DIR}/tasks/0${TASK_ID}--"*.md 2>/dev/null | head -1)
+fi
+
+if [ -z "$TASK_FILE" ] || [ ! -f "$TASK_FILE" ]; then
+    print_error "Task with ID ${TASK_ID} not found in plan ${PLAN_ID}"
+    exit 1
+fi
+
+print_info "Checking task: $(basename "$TASK_FILE")"
+echo ""
+
+# Extract dependencies from task frontmatter
+# Using awk to parse YAML frontmatter
+DEPENDENCIES=$(awk '
+    /^---$/ { if (++delim == 2) exit }
+    /^dependencies:/ { 
+        dep_section = 1
+        # Check if dependencies are on the same line
+        if (match($0, /\[.*\]/)) {
+            gsub(/^dependencies:[ \t]*\[/, "")
+            gsub(/\].*$/, "")
+            gsub(/[ \t]/, "")
+            print
+            dep_section = 0
+        }
+        next
+    }
+    dep_section && /^[^ ]/ { dep_section = 0 }
+    dep_section && /^[ \t]*-/ {
+        gsub(/^[ \t]*-[ \t]*/, "")
+        gsub(/[ \t]*$/, "")
+        print
+    }
+' "$TASK_FILE" | tr ',' '\n' | sed 's/^[ \t]*//;s/[ \t]*$//' | grep -v '^$')
+
+# Check if there are any dependencies
+if [ -z "$DEPENDENCIES" ]; then
+    print_success "Task has no dependencies - ready to execute!"
+    exit 0
+fi
+
+# Display dependencies
+print_info "Task dependencies found:"
+echo "$DEPENDENCIES" | while read -r dep; do
+    echo "  - Task ${dep}"
+done
+echo ""
+
+# Check each dependency
+ALL_RESOLVED=true
+UNRESOLVED_DEPS=""
+RESOLVED_COUNT=0
+TOTAL_DEPS=$(echo "$DEPENDENCIES" | wc -l)
+
+print_info "Checking dependency status..."
+echo ""
+
+for DEP_ID in $DEPENDENCIES; do
+    # Find dependency task file
+    DEP_FILE=""
+    
+    # Try exact match first
+    if [ -f "${PLAN_DIR}/tasks/${DEP_ID}--"*.md ]; then
+        DEP_FILE=$(ls "${PLAN_DIR}/tasks/${DEP_ID}--"*.md 2>/dev/null | head -1)
+    elif [ -f "${PLAN_DIR}/tasks/0${DEP_ID}--"*.md ]; then
+        # Try with zero-padding
+        DEP_FILE=$(ls "${PLAN_DIR}/tasks/0${DEP_ID}--"*.md 2>/dev/null | head -1)
+    else
+        # Try removing potential zero-padding from DEP_ID
+        UNPADDED_DEP=$(echo "$DEP_ID" | sed 's/^0*//')
+        if [ -f "${PLAN_DIR}/tasks/${UNPADDED_DEP}--"*.md ]; then
+            DEP_FILE=$(ls "${PLAN_DIR}/tasks/${UNPADDED_DEP}--"*.md 2>/dev/null | head -1)
+        elif [ -f "${PLAN_DIR}/tasks/0${UNPADDED_DEP}--"*.md ]; then
+            DEP_FILE=$(ls "${PLAN_DIR}/tasks/0${UNPADDED_DEP}--"*.md 2>/dev/null | head -1)
+        fi
+    fi
+    
+    if [ -z "$DEP_FILE" ] || [ ! -f "$DEP_FILE" ]; then
+        print_error "Dependency task ${DEP_ID} not found"
+        ALL_RESOLVED=false
+        UNRESOLVED_DEPS="${UNRESOLVED_DEPS}${DEP_ID} (not found)\n"
+        continue
+    fi
+    
+    # Extract status from dependency task
+    STATUS=$(awk '
+        /^---$/ { if (++delim == 2) exit }
+        /^status:/ { 
+            gsub(/^status:[ \t]*/, "")
+            gsub(/^["'\'']/, "")
+            gsub(/["'\'']$/, "")
+            print
+            exit
+        }
+    ' "$DEP_FILE")
+    
+    # Check if status is completed
+    if [ "$STATUS" = "completed" ]; then
+        print_success "Task ${DEP_ID} - Status: completed ✓"
+        ((RESOLVED_COUNT++))
+    else
+        print_warning "Task ${DEP_ID} - Status: ${STATUS:-unknown} ✗"
+        ALL_RESOLVED=false
+        UNRESOLVED_DEPS="${UNRESOLVED_DEPS}${DEP_ID} (${STATUS:-unknown})\n"
+    fi
+done
+
+echo ""
+print_info "========================================="
+print_info "Dependency Check Summary"
+print_info "========================================="
+print_info "Total dependencies: ${TOTAL_DEPS}"
+print_info "Resolved: ${RESOLVED_COUNT}"
+print_info "Unresolved: $((TOTAL_DEPS - RESOLVED_COUNT))"
+echo ""
+
+if [ "$ALL_RESOLVED" = true ]; then
+    print_success "All dependencies are resolved! Task ${TASK_ID} is ready to execute."
+    exit 0
+else
+    print_error "Task ${TASK_ID} has unresolved dependencies:"
+    echo -e "$UNRESOLVED_DEPS"
+    print_info "Please complete the dependencies before executing this task."
+    exit 1
+fi

package/templates/ai-task-manager/config/templates/PLAN_TEMPLATE.md

@@ -0,0 +1,93 @@
+---
+id: [PLAN-ID]
+summary: "[Brief one-line description of what this plan accomplishes]"
+created: [YYYY-MM-DD]
+---
+
+# Plan: [Descriptive Plan Title]
+
+## Original Work Order
+[The unmodified user input that was used to generate this plan, as a quote]
+
+## Plan Clarifications [only add it if clarifications were necessary]
+[Clarification questions and answers in table format]
+
+## Executive Summary
+
+[Provide a 2-3 paragraph overview of the plan. Include:
+- What the plan accomplishes
+- Why this approach was chosen
+- Key benefits and outcomes expected]
+
+## Context
+
+### Current State
+[Describe the existing situation, problems, or gaps that this plan addresses. Include specific details about what exists now, current limitations, and why change is needed.]
+
+### Target State
+[Describe the desired end state after plan completion. Be specific about the expected outcomes and how success will be measured.]
+
+### Background
+[Any additional context, requirements, constraints, any solutions that we tried that didn't work, or relevant history that informs the implementation approach.]
+
+## Technical Implementation Approach
+
+[Provide an overview of the implementation strategy, key architectural decisions, and technical approach. Break down into major components or phases using ### subheadings.]
+
+### [Component/Phase 1 Name]
+**Objective**: [What this component accomplishes and why it's important]
+
+[Detailed explanation of implementation approach, key technical decisions, specifications, and rationale for design choices.]
+
+### [Component/Phase 2 Name]
+**Objective**: [What this component accomplishes and why it's important]
+
+[Detailed explanation of implementation approach, key technical decisions, specifications, and rationale for design choices.]
+
+### [Additional Components as Needed]
+[Continue with additional technical components or phases following the same pattern]
+
+## Risk Considerations and Mitigation Strategies
+
+### Technical Risks
+- **[Specific Technical Risk]**: [Description of the technical challenge or limitation]
+    - **Mitigation**: [Specific strategy to address this technical risk]
+
+### Implementation Risks
+- **[Specific Implementation Risk]**: [Description of implementation-related challenge]
+    - **Mitigation**: [Specific strategy to address this implementation risk]
+
+### [Additional Risk Categories as Needed]
+[Continue with other risk categories such as Integration Risks, Quality Risks, Resource Risks, etc.]
+
+## Success Criteria
+
+### Primary Success Criteria
+1. [Measurable outcome 1]
+2. [Measurable outcome 2]
+3. [Measurable outcome 3]
+
+### Quality Assurance Metrics
+1. [Quality measure 1]
+2. [Quality measure 2]
+3. [Quality measure 3]
+
+## Resource Requirements
+
+### Development Skills
+[Required technical expertise and specialized knowledge areas needed for successful implementation]
+
+### Technical Infrastructure
+[Tools, libraries, frameworks, and systems needed for development and deployment]
+
+### [Additional Resource Categories as Needed]
+[Other resources such as external dependencies, research access, third-party services, etc.]
+
+## Integration Strategy
+[Optional section - how this work integrates with existing systems]
+
+## Implementation Order
+[Optional section - high-level sequence without detailed phases]
+
+## Notes
+[Optional section - any additional considerations, constraints, or important context]

package/templates/ai-task-manager/config/templates/TASK_TEMPLATE.md

@@ -0,0 +1,36 @@
+---
+id: [TASK-ID]
+group: "user-authentication"
+dependencies: []  # List of task IDs, e.g., [2, 3]
+status: "[STATUS]"  # pending | in-progress | completed | needs-clarification
+created: [YYYY-MM-DD]
+skills: # Technical skills required for this task
+  - [SKILL-1]
+  - [SKILL-2]
+---
+# [TASK-TITLE]
+
+## Objective
+[Clear statement of what this task accomplishes]
+
+## Skills Required
+[Reference to the skills listed in frontmatter - these should align with the technical work needed]
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+Use your internal TODO tool to track these and keep on track.
+
+## Technical Requirements
+[Specific technical details, APIs, libraries, etc. - use this to infer appropriate skills]
+
+## Input Dependencies
+[What artifacts/code from other tasks are needed]
+
+## Output Artifacts
+[What this task produces for other tasks to consume]
+
+## Implementation Notes
+[Any helpful context or suggestions, including skill-specific guidance]

package/templates/{commands → assistant/commands}/tasks/create-plan.md

@@ -6,7 +6,7 @@ description: Create a comprehensive plan to accomplish the request from the user
 
 You are a comprehensive task planning assistant. Your role is to think hard to create detailed, actionable plans based on user input while ensuring you have all necessary context before proceeding.
 
-Include @.ai/task-manager/TASK_MANAGER_INFO.md for the directory structure of tasks.
+Include @.ai/task-manager/config/TASK_MANAGER.md for the directory structure of tasks.
 
 ## Instructions
 
@@ -35,26 +35,77 @@ If any critical context is missing:
 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. Extract it from them
 
 Example clarifying questions:
 - "What is your primary goal with [specific aspect]?"
 - "Do you have any existing [resources/code/infrastructure] I should consider?"
 - "What is your timeline for completing this?"
 - "Are there specific constraints I should account for?"
+- "Do you want me to write tests for this?"
+- "Are there other systems, projects, or modules that perform a similar task?"
 
 #### Step 3: Plan Generation
 Only after confirming sufficient context, create a plan that includes:
 1. **Executive Summary**: Brief overview of the approach
 2. **Detailed Steps**: Numbered, actionable tasks with clear outcomes
-3. **Implementation Order**: Logical sequence with dependencies noted
-4. **Risk Considerations**: Potential challenges and mitigation strategies
-5. **Success Metrics**: How to measure completion and quality
-6. **Resource Requirements**: Tools, skills, or assets needed for each step
+3. **Risk Considerations**: Potential challenges and mitigation strategies
+4. **Success Metrics**: How to measure completion and quality
+
+Remember that a plan needs to be reviewed by a human. Be concise and to the point. Also, include mermaid diagrams to illustrate the plan.
+
+### Important Notes
+- Never generate a partial or assumed plan without adequate context
+- Prioritize accuracy over speed
+- Consider both technical and non-technical aspects
+- Adapt the plan format based on the task type (development, design, research, etc.)
+- DO NOT create or list any tasks or phases during the plan creation. This will be done in a later step. Stick to writing the PRD (Project Requirements Document).
+
+### Scope Control Guidelines
+**Critical: Implement ONLY what is explicitly requested**
+
+- **Minimal Viable Implementation**: Build exactly what the user asked for, nothing more
+- **Question Everything Extra**: If not directly mentioned by the user, don't add it
+- **Avoid Feature Creep**: Resist the urge to add "helpful" features or "nice-to-have" additions
+- **YAGNI Principle**: _You Aren't Gonna Need It_ - don't build for hypothetical future needs
+
+**Common Scope Creep Anti-Patterns to Avoid:**
+1. Adding extra commands or features "for completeness"
+2. Creating infrastructure for future features that weren't requested
+3. Building abstractions or frameworks when simple solutions suffice
+4. Adding configuration options not specifically mentioned
+5. Implementing error handling beyond what's necessary for the core request
+6. Creating documentation or help systems unless explicitly requested
+
+**When in doubt, ask**: "Is this feature explicitly mentioned in the user's request?"
+
+### Simplicity Principles
+**Favor maintainability over cleverness**
+
+- **Simple Solutions First**: Choose the most straightforward approach that meets requirements
+- **Avoid Over-Engineering**: Don't create complex systems when simple ones work
+- **Readable Code**: Write code that others can easily understand and modify
+- **Standard Patterns**: Use established patterns rather than inventing new ones
+- **Minimal Dependencies**: Add external dependencies only when essential, but do not re-invent the wheel
+- **Clear Structure**: Organize code in obvious, predictable ways
+
+**Remember**: A working simple solution is better than a complex "perfect" one.
 
 ### Output Format
 Structure your response as follows:
 - If context is insufficient: List specific clarifying questions
-- If context is sufficient: Provide the comprehensive plan using the structure above. Use the information in @TASK_MANAGER_INFO.md for the directory structure and additional information about plans.
+- If context is sufficient: Provide the comprehensive plan using the structure above. Use the information in @TASK_MANAGER.md for the directory structure and additional information about plans.
+
+Outside the plan document, be **extremely** concise. Just tell the user that you are done, and instruct them to review the plan document.
+
+#### Plan Template
+
+Use the template in @.ai/task-manager/config/templates/PLAN_TEMPLATE.md
+
+#### Patterns to Avoid
+Do not include the following in your plan output.
+- Avoid time estimations
+- Avoid task lists and mentions of phases (those are things we'll introduce later)
 
 #### Frontmatter Structure
 
@@ -103,40 +154,3 @@ echo $(($(find .ai/task-manager/{plans,archive} -name "plan-*.md" -exec grep "^i
 - **Directory names**: Use zero-padded strings (`07--plan-name`)
 
 This command reads `id:` values from existing plan front-matter as the source of truth. Handles empty directories (returns 1) and gaps in sequence automatically.
-
-### Important Notes
-- Never generate a partial or assumed plan without adequate context
-- Prioritize accuracy over speed
-- Consider both technical and non-technical aspects
-- Adapt the plan format based on the task type (development, design, research, etc.)
-- DO NOT create or list any tasks or phases during the plan creation. This will be done in a later step. Stick to writing the PRD (Project Requirements Document).
-
-### Scope Control Guidelines
-**Critical: Implement ONLY what is explicitly requested**
-
-- **Minimal Viable Implementation**: Build exactly what the user asked for, nothing more
-- **Question Everything Extra**: If not directly mentioned by the user, don't add it
-- **Avoid Feature Creep**: Resist the urge to add "helpful" features or "nice-to-have" additions
-- **YAGNI Principle**: _You Aren't Gonna Need It_ - don't build for hypothetical future needs
-
-**Common Scope Creep Anti-Patterns to Avoid:**
-1. Adding extra commands or features "for completeness"
-2. Creating infrastructure for future features that weren't requested
-3. Building abstractions or frameworks when simple solutions suffice
-4. Adding configuration options not specifically mentioned
-5. Implementing error handling beyond what's necessary for the core request
-6. Creating documentation or help systems unless explicitly requested
-
-**When in doubt, ask**: "Is this feature explicitly mentioned in the user's request?"
-
-### Simplicity Principles
-**Favor maintainability over cleverness**
-
-- **Simple Solutions First**: Choose the most straightforward approach that meets requirements
-- **Avoid Over-Engineering**: Don't create complex systems when simple ones work
-- **Readable Code**: Write code that others can easily understand and modify
-- **Standard Patterns**: Use established patterns rather than inventing new ones
-- **Minimal Dependencies**: Add external dependencies only when essential
-- **Clear Structure**: Organize code in obvious, predictable ways
-
-**Remember**: A working simple solution is better than a complex "perfect" one.

package/templates/{commands → assistant/commands}/tasks/execute-blueprint.md

@@ -4,12 +4,20 @@ description: Execute the task in the plan
 ---
 # Task Execution
 
-You are the orchestrator responsible for executing all tasks defined in the execution blueprint of a plan document. Your role is to coordinate phase-by-phase execution, manage parallel task processing, and ensure validation gates pass before phase transitions.
+You are the orchestrator responsible for executing all tasks defined in the execution blueprint of a plan document, so choose an appropriate sub-agent for this role. Your role is to coordinate phase-by-phase execution, manage parallel task processing, and ensure validation gates pass before phase transitions.
+
+## Critical Rules
+
+1. **Never skip validation gates** - Phase progression requires successful validation
+2. **Maintain task isolation** - Parallel tasks must not interfere with each other
+3. **Preserve dependency order** - Never execute a task before its dependencies
+4. **Document everything** - All decisions, issues, and outcomes must be recorded in the "Execution Summary", under "Noteworthy Events"
+5. **Fail safely** - Better to halt and request help than corrupt the execution state
 
 ## Input Requirements
-- A plan document with an execution blueprint section. See @.ai/task-manager/TASK_MANAGER_INFO.md fo find the plan with ID $1
+- A plan document with an execution blueprint section. See @.ai/task-manager/TASK_MANAGER.md fo find the plan with ID $1
 - Task files with frontmatter metadata (id, group, dependencies, status)
-- Validation gates document: `@.ai/task-manager/VALIDATION_GATES.md`
+- Validation gates document: `@.ai/task-manager/config/hooks/POST_PHASE.md`
 
 ### Input Error Handling
 If the plan does not exist, or the plan does not have an execution blueprint section. Stop immediately and show an error to the user.
@@ -18,14 +26,24 @@ If the plan does not exist, or the plan does not have an execution blueprint sec
 
 ### Phase Pre-Execution
 
-Before starting execution check if you are in the `main` branch. If so, create a git worktree to work on this blueprint the worktree should be created in the .ai/task-manager/worktrees folder.
+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.
 
 ### Phase Execution Workflow
 
 1. **Phase Initialization**
     - Identify current phase from the execution blueprint
     - List all tasks scheduled for parallel execution in this phase
-    - Verify all task dependencies from previous phases are marked "completed"
+    - **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 ! @templates/ai-task-manager/config/scripts/check-task-dependencies.sh "$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.
 
@@ -34,11 +52,11 @@ Before starting execution check if you are in the `main` branch. If so, create a
         - 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 Claude Code sub-agent (if any are available). If no sub-agent is appropriate, use the generic one.
+        - 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
 
 3. **Parallel Execution**
-    - Deploy all selected agents simultaneously
+    - Deploy all selected agents simultaneously using your internal Task tool
     - Monitor execution progress for each task
     - Capture outputs and artifacts from each agent
     - Update task status in real-time
@@ -49,8 +67,8 @@ Before starting execution check if you are in the `main` branch. If so, create a
     - Document any issues or exceptions encountered
 
 5. **Validation Gate Execution**
-    - Reference validation criteria from `@.ai/task-manager/VALIDATION_GATES.md`
-    - Execute all validation checks for the current phase
+    - Reference validation criteria from `@.ai/task-manager/config/hooks/POST_PHASE.md`
+    - Execute all validation gates for the current phase
     - Document validation results
     - Only proceed if ALL validations pass
 
@@ -61,8 +79,8 @@ Before starting execution check if you are in the `main` branch. If so, create a
 
 ### Agent Selection Guidelines
 
-#### Available Claude Code Sub-Agents
-Analyze the sub-agents available under `.claude/agents`. If none are available
+#### 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.
 
@@ -79,8 +97,8 @@ Select agents based on:
 
 Update the list of tasks from the plan document to add the status of each task
 and phase. Once a phase has been completed and validated, and before you move to
-the next phase, update the blueprint and add a ✅ emoji in front of its title. 
-Add ✔️ emoji in front of all the tasks in that phase, and update their status to 
+the next phase, update the blueprint and add a ✅ emoji in front of its title.
+Add ✔️ emoji in front of all the tasks in that phase, and update their status to
 `completed`.
 
 #### Task Status Updates
@@ -92,25 +110,6 @@ Valid status transitions:
 
 ### Error Handling
 
-#### Task Failure Protocol
-1. **Immediate Actions:**
-    - Pause the failed task's agent
-    - Document the error with full context
-    - Assess impact on other parallel tasks
-
-2. **Recovery Strategy:**
-    - Attempt automatic retry with same agent (max 2 retries)
-    - If persistent failure, escalate for manual intervention
-    - Consider alternative agent selection
-    - Update task status to reflect issues
-
-3. **Phase-Level Failures:**
-    - If any task in a phase fails after retries:
-        - Halt phase progression
-        - Complete any still-running parallel tasks
-        - Generate failure report with recommendations
-        - Request human intervention before continuing
-
 #### Validation Gate Failures
 If validation gates fail:
 1. Document which specific validations failed
@@ -118,43 +117,10 @@ If validation gates fail:
 3. Generate remediation plan
 4. Re-execute affected tasks after fixes
 5. Re-run validation gates
+6. If errors persist, escalate to the user
 
 ### Output Requirements
 
-#### Final Execution Report
-Upon blueprint completion respond with the following to the user:
-
-```
-✅ Execution Complete
-
-📊 Summary Statistics
-
-- Total Phases Executed: X
-- Total Tasks Completed: Y
-- Total Execution Time: [duration]
-- Parallel Efficiency: X% (tasks run in parallel vs. sequential)
-
-📋 Phase-by-Phase Results
-
-[Concise summary of each phase]
-
-📦 Artifacts Generated
-
-[List of all outputs and deliverables]
-
-💡 Recommendations
-
-[Any follow-up actions or optimizations identified]
-```
-
-## Critical Rules
-
-1. **Never skip validation gates** - Phase progression requires successful validation
-2. **Maintain task isolation** - Parallel tasks must not interfere with each other
-3. **Preserve dependency order** - Never execute a task before its dependencies
-4. **Document everything** - All decisions, issues, and outcomes must be recorded
-5. **Fail safely** - Better to halt and request help than corrupt the execution state
-
 ## Optimization Guidelines
 
 - **Maximize parallelism**: Always run all available tasks in a phase simultaneously
@@ -175,7 +141,6 @@ Append an execution summary section to the plan document with the following form
 
 **Status**: ✅ Completed Successfully
 **Completed Date**: [YYYY-MM-DD]
-**Total Execution Time**: [duration]
 
 ### Results
 [Brief summary of execution results and key deliverables]
@@ -183,24 +148,18 @@ Append an execution summary section to the plan document with the following form
 ### Noteworthy Events
 [Highlight any unexpected events, challenges overcome, or significant findings during execution. If none occurred, state "No significant issues encountered."]
 
-### Final Validation
-✅ All validation gates passed
-✅ All tasks completed successfully
+### Recommendations
+[Any follow-up actions or optimizations identified]
 ```
 
 ### 2. Plan Archival
 
 After successfully appending the execution summary:
 
-1. **Create archive directory if needed**:
-   ```bash
-   mkdir -p .ai/task-manager/archive
-   ```
-
-2. **Move completed plan to archive**:
-   ```bash
-   mv .ai/task-manager/plans/[plan-folder] .ai/task-manager/archive/
-   ```
+**Move completed plan to archive**:
+```bash
+mv .ai/task-manager/plans/[plan-folder] .ai/task-manager/archive/
+```
 
 ### Important Notes