claude-code-templates 1.21.5 → 1.21.6

package/components/commands/orchestration/move.md

@@ -0,0 +1,220 @@
+# Task Move Command
+
+Move tasks between status folders following the task management protocol.
+
+## Usage
+
+```
+/task-move TASK-ID new-status [reason]
+```
+
+## Description
+
+Updates task status by moving files between status folders and updating tracking information. Follows all protocol rules including validation and audit trails.
+
+## Basic Commands
+
+### Start Working on a Task
+```
+/task-move TASK-001 in_progress
+```
+Moves from todos → in_progress
+
+### Complete Implementation
+```
+/task-move TASK-001 qa "Implementation complete, ready for testing"
+```
+Moves from in_progress → qa
+
+### Task Passed QA
+```
+/task-move TASK-001 completed "All tests passed"
+```
+Moves from qa → completed
+
+### Block a Task
+```
+/task-move TASK-004 on_hold "Waiting for TASK-001 API completion"
+```
+Moves to on_hold with reason
+
+### Unblock a Task
+```
+/task-move TASK-004 todos "Dependencies resolved"
+```
+Moves from on_hold → todos
+
+### Failed QA
+```
+/task-move TASK-001 in_progress "Failed integration test - fixing null pointer"
+```
+Moves from qa → in_progress
+
+## Bulk Operations
+
+### Move Multiple Tasks
+```
+/task-move TASK-001,TASK-002,TASK-003 in_progress
+```
+
+### Move by Filter
+```
+/task-move --filter "priority:high status:todos" in_progress
+```
+
+### Move with Pattern
+```
+/task-move TASK-00* qa "Batch testing ready"
+```
+
+## Validation Rules
+
+The command enforces:
+1. **Valid Transitions**: Only allowed status changes
+2. **One Task Per Agent**: Warns if agent has task in_progress
+3. **Dependency Check**: Warns if dependencies not met
+4. **File Existence**: Verifies task exists before moving
+
+## Status Transition Map
+
+```
+todos ──────→ in_progress ──────→ qa ──────→ completed
+  ↓               ↓               ↓
+  └───────────→ on_hold ←─────────┘
+                  ↓
+                todos/in_progress
+```
+
+## Options
+
+### Force Move
+```
+/task-move TASK-001 completed --force
+```
+Bypasses validation (use with caution)
+
+### Dry Run
+```
+/task-move TASK-001 qa --dry-run
+```
+Shows what would happen without executing
+
+### With Assignment
+```
+/task-move TASK-001 in_progress --assign dev-frontend
+```
+Assigns task to specific agent
+
+### With Time Estimate
+```
+/task-move TASK-001 in_progress --estimate 4h
+```
+Updates time estimate when starting
+
+## Error Handling
+
+### Task Not Found
+```
+Error: TASK-999 not found in any status folder
+Suggestion: Use /task-status to see available tasks
+```
+
+### Invalid Transition
+```
+Error: Cannot move from 'completed' to 'todos'
+Valid transitions from completed: None (terminal state)
+```
+
+### Agent Conflict
+```
+Warning: dev-frontend already has TASK-002 in progress
+Continue? (y/n)
+```
+
+### Dependency Block
+```
+Warning: TASK-004 depends on TASK-001 (currently in_progress)
+Moving to on_hold instead? (y/n)
+```
+
+## Automation
+
+### Auto-move on Completion
+```
+/task-move TASK-001 --auto-progress
+```
+Automatically moves to next status when conditions met
+
+### Scheduled Moves
+```
+/task-move TASK-005 in_progress --at "tomorrow 9am"
+```
+
+### Conditional Moves
+```
+/task-move TASK-007 qa --when "TASK-006 completed"
+```
+
+## Examples
+
+### Example 1: Developer Workflow
+```
+# Start work
+/task-move TASK-001 in_progress
+
+# Complete and test
+/task-move TASK-001 qa "Implementation done, tests passing"
+
+# After review
+/task-move TASK-001 completed "Code review approved"
+```
+
+### Example 2: Handling Blocks
+```
+# Block due to dependency
+/task-move TASK-004 on_hold "Waiting for auth API from TASK-001"
+
+# Unblock when ready
+/task-move TASK-004 todos "TASK-001 now in QA, API available"
+```
+
+### Example 3: QA Workflow
+```
+# QA picks up task
+/task-move TASK-001 qa --assign qa-engineer
+
+# Found issues
+/task-move TASK-001 in_progress "Bug: handling empty responses"
+
+# Fixed and retesting
+/task-move TASK-001 qa "Bug fixed, ready for retest"
+```
+
+## Status Update Details
+
+Each move updates:
+1. **File Location**: Physical file movement
+2. **Status Tracker**: TASK-STATUS-TRACKER.yaml entry
+3. **Task Metadata**: Status field in task file
+4. **Execution Tracker**: Overall progress metrics
+
+## Best Practices
+
+1. **Always Provide Reasons**: Especially for blocks and failures
+2. **Check Dependencies**: Before moving to in_progress
+3. **Update Estimates**: When starting work
+4. **Clear Block Reasons**: Help others understand delays
+
+## Integration
+
+- Use after `/task-status` to see available tasks
+- Updates reflected in `/task-report`
+- Triggers notifications if configured
+- Logs all moves for audit trail
+
+## Notes
+
+- Moves are atomic - either fully complete or rolled back
+- Status history is permanent and cannot be edited
+- Timestamp uses current time in ISO-8601 format
+- Agent name is automatically detected from context

package/components/commands/orchestration/optimize.md

@@ -0,0 +1,375 @@
+# Orchestration Optimize Command
+
+Analyze and optimize task orchestrations to improve efficiency, reduce bottlenecks, and maximize team productivity.
+
+## Usage
+
+```
+/orchestration/optimize [options]
+```
+
+## Description
+
+Performs comprehensive analysis of active and historical orchestrations to identify optimization opportunities, suggest workflow improvements, and provide actionable insights for better task management.
+
+## Basic Commands
+
+### Analyze Current Orchestration
+```
+/orchestration/optimize
+```
+Analyzes the most recently active orchestration for bottlenecks and inefficiencies.
+
+### Optimize Specific Orchestration
+```
+/orchestration/optimize --date 03_15_2024 --project auth_system
+```
+Deep analysis of a specific orchestration with detailed recommendations.
+
+### Performance Analysis
+```
+/orchestration/optimize --performance
+```
+Focuses on timing, velocity, and resource utilization metrics.
+
+### Dependency Optimization
+```
+/orchestration/optimize --dependencies
+```
+Analyzes task dependencies for parallelization opportunities.
+
+## Analysis Areas
+
+### Bottleneck Detection
+```
+## Identified Bottlenecks
+
+Critical Path Analysis:
+- TASK-003 (JWT validation): Blocking 4 downstream tasks
+- Duration: 5.5h (150% of estimate)
+- Impact: 12h of parallel work delayed
+
+Queue Analysis:
+- on_hold queue: 6 tasks (avg 2.3 days waiting)
+- QA queue: 3 tasks (avg 8h waiting)
+- Recommendation: Add QA capacity or parallel testing
+
+Resource Constraints:
+- dev-backend: 3 active tasks (overloaded)
+- dev-frontend: 0 active tasks (underutilized)
+- Suggestion: Cross-train or reassign suitable tasks
+```
+
+### Velocity Metrics
+```
+## Velocity Analysis
+
+Current Metrics:
+- Tasks/day: 2.1 (target: 3.0)
+- Avg task duration: 4.2h (vs 3.5h estimate)
+- Status transitions: todos→in_progress (2h avg wait)
+
+Historical Comparison:
+- Last week: 2.8 tasks/day (33% faster)
+- Best week: 3.4 tasks/day (optimal conditions)
+
+Trending Issues:
+- Estimate accuracy declining (65% vs 80% last month)
+- QA feedback loop increased by 40%
+```
+
+### Dependency Analysis
+```
+## Dependency Optimization
+
+Parallelization Opportunities:
+1. TASK-007, TASK-008 can run concurrently with TASK-003
+   Potential time saving: 6 hours
+
+2. Frontend tasks independent of current backend work
+   Parallelizable: TASK-009, TASK-010, TASK-011
+
+Critical Path Optimization:
+- Current: 24 hours (sequential)
+- Optimized: 16 hours (parallel execution)
+- Savings: 8 hours (33% improvement)
+
+Dependency Simplification:
+- Remove false dependency: TASK-012 → TASK-004
+- Merge related tasks: TASK-014 + TASK-015
+```
+
+## Optimization Strategies
+
+### Resource Reallocation
+```
+/orchestration/optimize --rebalance
+```
+
+Suggests optimal task assignments:
+```
+## Recommended Resource Changes
+
+Current Load:
+┌─────────────────┬────────────┬─────────────┬────────────┐
+│ Agent           │ Active     │ Queue       │ Utilization│
+├─────────────────┼────────────┼─────────────┼────────────┤
+│ dev-backend     │ 3 tasks    │ 2 tasks     │ 180%       │
+│ dev-frontend    │ 0 tasks    │ 4 tasks     │ 0%         │
+│ qa-engineer     │ 2 tasks    │ 1 task      │ 120%       │
+│ test-developer  │ 1 task     │ 0 tasks     │ 60%        │
+└─────────────────┴────────────┴─────────────┴────────────┘
+
+Recommendations:
+1. Move TASK-007 (API tests) to test-developer
+2. Assign TASK-009 (UI components) to dev-frontend
+3. Split TASK-003 into backend/frontend components
+```
+
+### Task Restructuring
+```
+/orchestration/optimize --restructure
+```
+
+Suggests task modifications:
+```
+## Task Restructuring Opportunities
+
+Oversized Tasks (>6h estimate):
+- TASK-003: JWT validation (8h) 
+  → Split: JWT core (4h) + JWT middleware (3h) + Tests (1h)
+
+Undersized Tasks (<1h estimate):
+- TASK-011: Update config (0.5h)
+- TASK-012: Fix typos (0.25h)
+  → Merge into maintenance batch
+
+Mislabeled Dependencies:
+- TASK-008 doesn't actually need TASK-003
+  → Remove dependency, add to parallel execution
+```
+
+### Workflow Improvements
+```
+/orchestration/optimize --workflow
+```
+
+Process optimization suggestions:
+```
+## Workflow Optimization
+
+Status Transition Delays:
+- todos → in_progress: 4.2h avg (target: <2h)
+- in_progress → qa: 1.2h avg (good)
+- qa → completed: 6.8h avg (target: <4h)
+
+Recommendations:
+1. Implement auto-assignment rules
+2. Add QA capacity during peak hours
+3. Create task preparation checklist
+
+Communication Improvements:
+- 23% of blocks due to unclear requirements
+- 15% of QA failures from missing context
+- Add requirement review gate before in_progress
+```
+
+## Historical Analysis
+
+### Trend Analysis
+```
+/orchestration/optimize --trends --days 30
+```
+
+Shows performance trends:
+```
+## 30-Day Performance Trends
+
+Velocity Trend: ↓ -15%
+- Week 1: 3.2 tasks/day
+- Week 2: 2.9 tasks/day  
+- Week 3: 2.8 tasks/day
+- Week 4: 2.7 tasks/day
+
+Quality Trend: ↓ -8%
+- QA rejection rate increasing
+- Rework time per task up 12%
+
+Efficiency Indicators:
+- Estimate accuracy: 68% (down from 78%)
+- Parallel execution rate: 45% (up from 40%)
+- Blocked task duration: 1.8 days avg (up from 1.2 days)
+```
+
+### Pattern Recognition
+```
+## Identified Patterns
+
+Task Types Performance:
+- Features: 3.2h avg (close to estimates)
+- Bugfixes: 2.1h avg (underestimated by 40%)
+- Tests: 1.8h avg (overestimated by 20%)
+- Security: 5.1h avg (significantly underestimated)
+
+Time-of-Day Patterns:
+- Morning starts: 25% faster completion
+- Post-lunch blocks: 40% more likely
+- End-of-day QA: 60% higher failure rate
+
+Agent Specialization:
+- dev-backend: 2x faster on API tasks
+- dev-frontend: 30% faster on UI tasks
+- Cross-functional tasks: 50% slower than specialized
+```
+
+## Optimization Actions
+
+### Immediate Actions
+```
+/orchestration/optimize --execute immediate
+```
+
+Applies safe optimizations:
+1. Rebalance current task assignments
+2. Remove identified false dependencies
+3. Update task estimates based on historical data
+4. Reschedule blocked tasks
+
+### Structural Changes
+```
+/orchestration/optimize --execute structural --confirm
+```
+
+Requires confirmation for:
+1. Task splitting/merging
+2. Workflow process changes
+3. Agent role modifications
+4. Dependency restructuring
+
+### Continuous Optimization
+```
+/orchestration/optimize --schedule daily
+```
+
+Sets up automated optimization:
+- Daily velocity monitoring
+- Weekly bottleneck analysis
+- Monthly trend reporting
+- Automated rebalancing suggestions
+
+## Simulation Mode
+
+### What-If Analysis
+```
+/orchestration/optimize --simulate "add agent:dev-fullstack"
+```
+
+Projects impact of changes:
+```
+## Simulation Results: Adding dev-fullstack
+
+Projected Improvements:
+- Velocity: 2.7 → 3.4 tasks/day (+26%)
+- Critical path: 24h → 18h (-25%)
+- Queue time: 4.2h → 2.1h (-50%)
+
+Resource Utilization:
+- Backend overload: 180% → 120% (optimal)
+- Frontend underload: 0% → 80% (good)
+- Overall efficiency: +35%
+
+ROI Analysis:
+- Cost: +1 team member
+- Delivery speed: +26%
+- Quality impact: Neutral to positive
+```
+
+## Integration Features
+
+### Automated Optimization
+```
+/orchestration/optimize --auto-apply --threshold conservative
+```
+
+Automatically applies optimizations meeting conservative safety criteria.
+
+### Notification System
+```
+/orchestration/optimize --alerts bottleneck,velocity,quality
+```
+
+Sets up alerts for optimization opportunities.
+
+### Historical Learning
+```
+/orchestration/optimize --learn-from previous_projects/
+```
+
+Incorporates lessons from past orchestrations.
+
+## Reporting
+
+### Optimization Report
+```
+/orchestration/optimize --report detailed
+```
+
+Generates comprehensive optimization report with:
+- Current state analysis
+- Identified opportunities  
+- Recommended actions
+- Expected impact metrics
+- Implementation timeline
+
+### Executive Summary
+```
+/orchestration/optimize --summary executive
+```
+
+High-level optimization insights for leadership.
+
+## Best Practices
+
+1. **Regular Analysis**: Run optimization weekly on active orchestrations
+2. **Incremental Changes**: Apply optimizations gradually to measure impact
+3. **Monitor Impact**: Track metrics before and after optimization
+4. **Team Communication**: Share optimization insights with the team
+5. **Continuous Learning**: Use historical data to improve future orchestrations
+
+## Examples
+
+### Example 1: Daily Optimization Check
+```
+/orchestration/optimize --quick --auto-rebalance
+```
+
+### Example 2: Deep Analysis for Struggling Project
+```
+/orchestration/optimize --date 03_15_2024 --project auth_system --deep-analysis
+```
+
+### Example 3: Team Performance Review
+```
+/orchestration/optimize --trends --days 90 --team-focus
+```
+
+## Configuration
+
+### Optimization Rules
+Set in orchestration config:
+```yaml
+optimization:
+  auto_rebalance: true
+  bottleneck_threshold: 2h
+  velocity_target: 3.0
+  quality_threshold: 85%
+  parallel_execution_target: 60%
+```
+
+## Notes
+
+- All optimizations are reversible through audit trail
+- Simulation mode allows safe experimentation
+- Historical data improves optimization accuracy over time
+- Integrates with all other orchestration commands
+- Supports custom optimization rules per project type