claude-code-templates 1.21.1 → 1.21.3

package/cli-tool/components/commands/orchestration/move.md

@@ -1,220 +0,0 @@
-# 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/cli-tool/components/commands/orchestration/optimize.md

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