Consolidate workflows and tools from commands repository

Repository Restructure:
- Move all 83 agent .md files to agents/ subdirectory
- Add 15 workflow orchestrators from commands repo to workflows/
- Add 42 development tools from commands repo to tools/
- Update README for unified repository structure

The commands repository functionality is now fully integrated, providing
complete workflow orchestration and development tooling alongside agents.

Directory Structure:
- agents/    - 83 specialized AI agents
- workflows/ - 15 multi-agent orchestration commands
- tools/     - 42 focused development utilities

No breaking changes to agent functionality - all agents remain accessible
with same names and behavior. Adds workflow and tool commands for enhanced
multi-agent coordination capabilities.

tools/tdd-refactor.md

@@ -0,0 +1,179 @@
+---
+model: claude-opus-4-1
+---
+
+Refactor code with confidence using comprehensive test safety net:
+
+[Extended thinking: This tool uses the tdd-orchestrator agent (opus model) for sophisticated refactoring while maintaining all tests green. It applies design patterns, improves code quality, and optimizes performance with the safety of comprehensive test coverage.]
+
+## Refactoring Process
+
+Use Task tool with subagent_type="tdd-orchestrator" to perform safe refactoring.
+
+Prompt: "Refactor this code while keeping all tests green: $ARGUMENTS. Apply TDD refactor phase excellence:
+
+1. **Pre-Refactoring Assessment**
+   - Analyze current code structure and identify code smells
+   - Review test coverage to ensure safety net is comprehensive
+   - Identify refactoring opportunities and prioritize by impact
+   - Run all tests to establish green baseline
+   - Document current performance metrics for comparison
+   - Create refactoring plan with incremental steps
+
+2. **Code Smell Detection**
+   - **Duplicated Code**: Extract methods, pull up to base classes
+   - **Long Methods**: Decompose into smaller, focused functions
+   - **Large Classes**: Split responsibilities, extract classes
+   - **Long Parameter Lists**: Introduce parameter objects
+   - **Feature Envy**: Move methods to appropriate classes
+   - **Data Clumps**: Group related data into objects
+   - **Primitive Obsession**: Replace with value objects
+   - **Switch Statements**: Replace with polymorphism
+   - **Parallel Inheritance**: Merge hierarchies
+   - **Dead Code**: Remove unused code paths
+
+3. **Design Pattern Application**
+   - **Creational Patterns**: Factory, Builder, Singleton where appropriate
+   - **Structural Patterns**: Adapter, Facade, Decorator for flexibility
+   - **Behavioral Patterns**: Strategy, Observer, Command for decoupling
+   - **Domain Patterns**: Repository, Service, Value Objects
+   - **Architecture Patterns**: Hexagonal, Clean Architecture principles
+   - Apply patterns only where they add clear value
+   - Avoid pattern overuse and unnecessary complexity
+
+4. **SOLID Principles Enforcement**
+   - **Single Responsibility**: One reason to change per class
+   - **Open/Closed**: Open for extension, closed for modification
+   - **Liskov Substitution**: Subtypes must be substitutable
+   - **Interface Segregation**: Small, focused interfaces
+   - **Dependency Inversion**: Depend on abstractions
+   - Balance principles with pragmatic simplicity
+
+5. **Refactoring Techniques Catalog**
+   - **Extract Method**: Isolate code blocks into named methods
+   - **Inline Method**: Remove unnecessary indirection
+   - **Extract Variable**: Name complex expressions
+   - **Rename**: Improve names for clarity and intent
+   - **Move Method/Field**: Relocate to appropriate classes
+   - **Extract Interface**: Define contracts explicitly
+   - **Replace Magic Numbers**: Use named constants
+   - **Encapsulate Field**: Add getters/setters for control
+   - **Replace Conditional with Polymorphism**: Object-oriented solutions
+   - **Introduce Null Object**: Eliminate null checks
+
+6. **Performance Optimization**
+   - Profile code to identify actual bottlenecks
+   - Optimize algorithms and data structures
+   - Implement caching where beneficial
+   - Reduce database queries and network calls
+   - Lazy loading and pagination strategies
+   - Memory usage optimization
+   - Always measure before and after changes
+   - Keep optimizations that provide measurable benefit
+
+7. **Code Quality Improvements**
+   - **Naming**: Clear, intentional, domain-specific names
+   - **Comments**: Remove obvious, add why not what
+   - **Formatting**: Consistent style throughout codebase
+   - **Error Handling**: Explicit, recoverable, informative
+   - **Logging**: Strategic placement, appropriate levels
+   - **Documentation**: Update to reflect changes
+   - **Type Safety**: Strengthen types where possible
+
+8. **Incremental Refactoring Steps**
+   - Make small, atomic changes
+   - Run tests after each modification
+   - Commit after each successful refactoring
+   - Use IDE refactoring tools when available
+   - Manual refactoring for complex transformations
+   - Keep refactoring separate from behavior changes
+   - Create temporary scaffolding when needed
+
+9. **Architecture Evolution**
+   - Layer separation and dependency management
+   - Module boundaries and interface definition
+   - Service extraction for microservices preparation
+   - Event-driven patterns for decoupling
+   - Async patterns for scalability
+   - Database access patterns optimization
+   - API design improvements
+
+10. **Quality Metrics Tracking**
+    - **Cyclomatic Complexity**: Reduce decision points
+    - **Code Coverage**: Maintain or improve percentage
+    - **Coupling**: Decrease interdependencies
+    - **Cohesion**: Increase related functionality grouping
+    - **Technical Debt**: Measure reduction achieved
+    - **Performance**: Response time and resource usage
+    - **Maintainability Index**: Track improvement
+    - **Code Duplication**: Percentage reduction
+
+11. **Safety Verification**
+    - Run full test suite after each change
+    - Use mutation testing to verify test effectiveness
+    - Performance regression testing
+    - Integration testing for architectural changes
+    - Manual exploratory testing for UX changes
+    - Code review checkpoint documentation
+    - Rollback plan for each major change
+
+12. **Advanced Refactoring Patterns**
+    - **Strangler Fig**: Gradual legacy replacement
+    - **Branch by Abstraction**: Large-scale changes
+    - **Parallel Change**: Expand-contract pattern
+    - **Mikado Method**: Dependency graph navigation
+    - **Preparatory Refactoring**: Enable feature addition
+    - **Feature Toggles**: Safe production deployment
+
+Output should include:
+- Refactored code with all improvements applied
+- Test results confirming all tests remain green
+- Before/after metrics comparison
+- List of applied refactoring techniques
+- Performance improvement measurements
+- Code quality metrics improvement
+- Documentation of architectural changes
+- Remaining technical debt assessment
+- Recommendations for future refactoring"
+
+## Refactoring Safety Checklist
+
+Before committing refactored code:
+1. ✓ All tests pass (100% green)
+2. ✓ No functionality regression
+3. ✓ Performance metrics acceptable
+4. ✓ Code coverage maintained/improved
+5. ✓ Documentation updated
+6. ✓ Team code review completed
+
+## Recovery Process
+
+If tests fail during refactoring:
+- Immediately revert last change
+- Identify which refactoring broke tests
+- Apply smaller, incremental changes
+- Consider if tests need updating (behavior change)
+- Use version control for safe experimentation
+- Leverage IDE's undo functionality
+
+## Integration Points
+
+- Follows from tdd-green.md implementation
+- Coordinates with test-automator for test updates
+- Integrates with static analysis tools
+- Triggers performance benchmarks
+- Updates architecture documentation
+- Links to CI/CD for deployment readiness
+
+## Best Practices
+
+- Refactor in small, safe steps
+- Keep tests green throughout process
+- Commit after each successful refactoring
+- Don't mix refactoring with feature changes
+- Use tools but understand manual techniques
+- Focus on high-impact improvements first
+- Leave code better than you found it
+- Document why, not just what changed
+
+Code to refactor: $ARGUMENTS