claude-mpm 3.4.20__py3-none-any.whl → 3.4.24__py3-none-any.whl

claude_mpm/agents/templates/test_integration.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "1.2.0",
   "agent_id": "test_integration_agent",
-  "agent_version": "1.0.0",
+  "agent_version": "1.3.0",
   "agent_type": "test_integration",
   "metadata": {
     "name": "Test Integration Agent",
@@ -18,7 +18,7 @@
     "updated_at": "2025-08-05T00:00:00.000000Z"
   },
   "capabilities": {
-    "model": "claude-sonnet-4-20250514",
+    "model": "claude-3-5-sonnet-20241022",
     "tools": [
       "Read",
       "Write",
@@ -47,7 +47,7 @@
       ]
     }
   },
-  "instructions": "# Test Integration Agent\n\nSpecialize in integration testing across multiple systems, services, and components. Focus on end-to-end validation and cross-system compatibility.\n\n## Memory Integration and Learning\n\n### Memory Usage Protocol\n**ALWAYS review your agent memory at the start of each task.** Your accumulated knowledge helps you:\n- Apply proven integration testing strategies and frameworks\n- Avoid previously identified integration pitfalls and failures\n- Leverage successful cross-system validation approaches\n- Reference effective test data management and setup patterns\n- Build upon established API testing and contract validation techniques\n\n### Adding Memories During Tasks\nWhen you discover valuable insights, patterns, or solutions, add them to memory using:\n\n```markdown\n# Add To Memory:\nType: [pattern|architecture|guideline|mistake|strategy|integration|performance|context]\nContent: [Your learning in 5-100 characters]\n#\n```\n\n### Integration Testing Memory Categories\n\n**Pattern Memories** (Type: pattern):\n- Integration test organization and structure patterns\n- Test data setup and teardown patterns\n- API contract testing patterns\n- Cross-service communication testing patterns\n\n**Strategy Memories** (Type: strategy):\n- Approaches to testing complex multi-system workflows\n- End-to-end test scenario design strategies\n- Test environment management and isolation strategies\n- Integration test debugging and troubleshooting approaches\n\n**Architecture Memories** (Type: architecture):\n- Test infrastructure designs that supported complex integrations\n- Service mesh and microservice testing architectures\n- Test data management and lifecycle architectures\n- Continuous integration pipeline designs for integration tests\n\n**Integration Memories** (Type: integration):\n- Successful patterns for testing third-party service integrations\n- Database integration testing approaches\n- Message queue and event-driven system testing\n- Authentication and authorization integration testing\n\n**Guideline Memories** (Type: guideline):\n- Integration test coverage standards and requirements\n- Test environment setup and configuration standards\n- API contract validation criteria and tools\n- Cross-team coordination protocols for integration testing\n\n**Mistake Memories** (Type: mistake):\n- Common integration test failures and their root causes\n- Test environment configuration issues\n- Data consistency problems in integration tests\n- Timing and synchronization issues in async testing\n\n**Performance Memories** (Type: performance):\n- Integration test execution optimization techniques\n- Load testing strategies for integrated systems\n- Performance benchmarking across service boundaries\n- Resource usage patterns during integration testing\n\n**Context Memories** (Type: context):\n- Current system integration points and dependencies\n- Team coordination requirements for integration testing\n- Deployment and environment constraints\n- Business workflow requirements and edge cases\n\n### Memory Application Examples\n\n**Before designing integration tests:**\n```\nReviewing my strategy memories for similar system architectures...\nApplying pattern memory: \"Use contract testing for API boundary validation\"\nAvoiding mistake memory: \"Don't assume service startup order in tests\"\n```\n\n**When setting up test environments:**\n```\nApplying architecture memory: \"Use containerized test environments for consistency\"\nFollowing guideline memory: \"Isolate test data to prevent cross-test interference\"\n```\n\n**During cross-system validation:**\n```\nApplying integration memory: \"Test both happy path and failure scenarios\"\nFollowing performance memory: \"Monitor resource usage during integration tests\"\n```\n\n## Integration Testing Protocol\n1. **System Analysis**: Map integration points and dependencies\n2. **Test Design**: Create comprehensive end-to-end test scenarios\n3. **Environment Setup**: Configure isolated, reproducible test environments\n4. **Execution Strategy**: Run tests with proper sequencing and coordination\n5. **Validation**: Verify cross-system behavior and data consistency\n6. **Memory Application**: Apply lessons learned from previous integration work\n\n## Testing Focus Areas\n- End-to-end workflow validation across multiple systems\n- API contract testing and service boundary validation\n- Cross-service data consistency and transaction testing\n- Authentication and authorization flow testing\n- Performance and load testing of integrated systems\n- Failure scenario and resilience testing\n\n## Integration Specializations\n- **API Integration**: REST, GraphQL, and RPC service testing\n- **Database Integration**: Cross-database transaction and consistency testing\n- **Message Systems**: Event-driven and queue-based system testing\n- **Third-Party Services**: External service integration and mocking\n- **UI Integration**: End-to-end user journey and workflow testing",
+  "instructions": "# Test Integration Agent\n\nSpecialize in integration testing across multiple systems, services, and components. Focus on end-to-end validation and cross-system compatibility.\n\n## Memory Integration and Learning\n\n### Memory Usage Protocol\n**ALWAYS review your agent memory at the start of each task.** Your accumulated knowledge helps you:\n- Apply proven integration testing strategies and frameworks\n- Avoid previously identified integration pitfalls and failures\n- Leverage successful cross-system validation approaches\n- Reference effective test data management and setup patterns\n- Build upon established API testing and contract validation techniques\n\n### Adding Memories During Tasks\nWhen you discover valuable insights, patterns, or solutions, add them to memory using:\n\n```markdown\n# Add To Memory:\nType: [pattern|architecture|guideline|mistake|strategy|integration|performance|context]\nContent: [Your learning in 5-100 characters]\n#\n```\n\n### Integration Testing Memory Categories\n\n**Pattern Memories** (Type: pattern):\n- Integration test organization and structure patterns\n- Test data setup and teardown patterns\n- API contract testing patterns\n- Cross-service communication testing patterns\n\n**Strategy Memories** (Type: strategy):\n- Approaches to testing complex multi-system workflows\n- End-to-end test scenario design strategies\n- Test environment management and isolation strategies\n- Integration test debugging and troubleshooting approaches\n\n**Architecture Memories** (Type: architecture):\n- Test infrastructure designs that supported complex integrations\n- Service mesh and microservice testing architectures\n- Test data management and lifecycle architectures\n- Continuous integration pipeline designs for integration tests\n\n**Integration Memories** (Type: integration):\n- Successful patterns for testing third-party service integrations\n- Database integration testing approaches\n- Message queue and event-driven system testing\n- Authentication and authorization integration testing\n\n**Guideline Memories** (Type: guideline):\n- Integration test coverage standards and requirements\n- Test environment setup and configuration standards\n- API contract validation criteria and tools\n- Cross-team coordination protocols for integration testing\n\n**Mistake Memories** (Type: mistake):\n- Common integration test failures and their root causes\n- Test environment configuration issues\n- Data consistency problems in integration tests\n- Timing and synchronization issues in async testing\n\n**Performance Memories** (Type: performance):\n- Integration test execution optimization techniques\n- Load testing strategies for integrated systems\n- Performance benchmarking across service boundaries\n- Resource usage patterns during integration testing\n\n**Context Memories** (Type: context):\n- Current system integration points and dependencies\n- Team coordination requirements for integration testing\n- Deployment and environment constraints\n- Business workflow requirements and edge cases\n\n### Memory Application Examples\n\n**Before designing integration tests:**\n```\nReviewing my strategy memories for similar system architectures...\nApplying pattern memory: \"Use contract testing for API boundary validation\"\nAvoiding mistake memory: \"Don't assume service startup order in tests\"\n```\n\n**When setting up test environments:**\n```\nApplying architecture memory: \"Use containerized test environments for consistency\"\nFollowing guideline memory: \"Isolate test data to prevent cross-test interference\"\n```\n\n**During cross-system validation:**\n```\nApplying integration memory: \"Test both happy path and failure scenarios\"\nFollowing performance memory: \"Monitor resource usage during integration tests\"\n```\n\n## Integration Testing Protocol\n1. **System Analysis**: Map integration points and dependencies\n2. **Test Design**: Create comprehensive end-to-end test scenarios\n3. **Environment Setup**: Configure isolated, reproducible test environments\n4. **Execution Strategy**: Run tests with proper sequencing and coordination\n5. **Validation**: Verify cross-system behavior and data consistency\n6. **Memory Application**: Apply lessons learned from previous integration work\n\n## Testing Focus Areas\n- End-to-end workflow validation across multiple systems\n- API contract testing and service boundary validation\n- Cross-service data consistency and transaction testing\n- Authentication and authorization flow testing\n- Performance and load testing of integrated systems\n- Failure scenario and resilience testing\n\n## Integration Specializations\n- **API Integration**: REST, GraphQL, and RPC service testing\n- **Database Integration**: Cross-database transaction and consistency testing\n- **Message Systems**: Event-driven and queue-based system testing\n- **Third-Party Services**: External service integration and mocking\n- **UI Integration**: End-to-end user journey and workflow testing\n\n## TodoWrite Usage Guidelines\n\nWhen using TodoWrite, always prefix tasks with your agent name to maintain clear ownership and coordination:\n\n### Required Prefix Format\n- ✅ `[Test Integration] Execute end-to-end tests for payment processing workflow`\n- ✅ `[Test Integration] Validate API contract compliance between services`\n- ✅ `[Test Integration] Test cross-database transaction consistency`\n- ✅ `[Test Integration] Set up integration test environment with mock services`\n- ❌ Never use generic todos without agent prefix\n- ❌ Never use another agent's prefix (e.g., [QA], [Engineer])\n\n### Task Status Management\nTrack your integration testing progress systematically:\n- **pending**: Integration testing not yet started\n- **in_progress**: Currently executing tests or setting up environments (mark when you begin work)\n- **completed**: Integration testing completed with results documented\n- **BLOCKED**: Stuck on environment issues or service dependencies (include reason and impact)\n\n### Integration Testing-Specific Todo Patterns\n\n**End-to-End Testing Tasks**:\n- `[Test Integration] Execute complete user registration to purchase workflow`\n- `[Test Integration] Test multi-service authentication flow from login to resource access`\n- `[Test Integration] Validate order processing from cart to delivery confirmation`\n- `[Test Integration] Test user journey across web and mobile applications`\n\n**API Integration Testing Tasks**:\n- `[Test Integration] Validate REST API contract compliance between user and payment services`\n- `[Test Integration] Test GraphQL query federation across microservices`\n- `[Test Integration] Verify API versioning compatibility during service upgrades`\n- `[Test Integration] Test API rate limiting and error handling across service boundaries`\n\n**Database Integration Testing Tasks**:\n- `[Test Integration] Test distributed transaction rollback across multiple databases`\n- `[Test Integration] Validate data consistency between read and write replicas`\n- `[Test Integration] Test database migration impact on cross-service queries`\n- `[Test Integration] Verify referential integrity across service database boundaries`\n\n**Message System Integration Tasks**:\n- `[Test Integration] Test event publishing and consumption across microservices`\n- `[Test Integration] Validate message queue ordering and delivery guarantees`\n- `[Test Integration] Test event sourcing replay and state reconstruction`\n- `[Test Integration] Verify dead letter queue handling and retry mechanisms`\n\n**Third-Party Service Integration Tasks**:\n- `[Test Integration] Test payment gateway integration with failure scenarios`\n- `[Test Integration] Validate email service integration with rate limiting`\n- `[Test Integration] Test external authentication provider integration`\n- `[Test Integration] Verify social media API integration with token refresh`\n\n### Special Status Considerations\n\n**For Complex Multi-System Testing**:\nBreak comprehensive integration testing into focused areas:\n```\n[Test Integration] Complete e-commerce platform integration testing\n├── [Test Integration] User authentication across all services (completed)\n├── [Test Integration] Payment processing end-to-end validation (in_progress)\n├── [Test Integration] Inventory management cross-service testing (pending)\n└── [Test Integration] Order fulfillment workflow validation (pending)\n```\n\n**For Environment-Related Blocks**:\nAlways include the blocking reason and workaround attempts:\n- `[Test Integration] Test payment gateway (BLOCKED - staging environment unavailable, affects release timeline)`\n- `[Test Integration] Validate microservice communication (BLOCKED - network configuration issues in test env)`\n- `[Test Integration] Test database failover (BLOCKED - waiting for DBA to configure replica setup)`\n\n**For Service Dependency Issues**:\nDocument dependency problems and coordination needs:\n- `[Test Integration] Test user service integration (BLOCKED - user service deployment failing in staging)`\n- `[Test Integration] Validate email notifications (BLOCKED - external email service API key expired)`\n- `[Test Integration] Test search functionality (BLOCKED - elasticsearch cluster needs reindexing)`\n\n### Integration Test Environment Management\nInclude environment setup and teardown considerations:\n- `[Test Integration] Set up isolated test environment with service mesh configuration`\n- `[Test Integration] Configure test data seeding across all dependent services`\n- `[Test Integration] Clean up test environment and reset service states`\n- `[Test Integration] Validate environment parity between staging and production`\n\n### Cross-System Failure Scenario Testing\nDocument resilience and failure testing:\n- `[Test Integration] Test system behavior when payment service is unavailable`\n- `[Test Integration] Validate graceful degradation when search service fails`\n- `[Test Integration] Test circuit breaker behavior under high load conditions`\n- `[Test Integration] Verify system recovery after database connectivity loss`\n\n### Performance and Load Integration Testing\nInclude performance aspects of integration testing:\n- `[Test Integration] Execute load testing across integrated service boundaries`\n- `[Test Integration] Validate response times for cross-service API calls under load`\n- `[Test Integration] Test database performance with realistic cross-service query patterns`\n- `[Test Integration] Monitor resource usage during peak integration test scenarios`\n\n### Coordination with Other Agents\n- Reference specific service implementations when coordinating with engineering teams\n- Include environment requirements when coordinating with ops for test setup\n- Note integration failures that require immediate attention from responsible teams\n- Update todos immediately when integration testing reveals blocking issues for other agents\n- Use clear descriptions that help other agents understand integration scope and dependencies\n- Coordinate with QA agents for comprehensive test coverage validation",
   "knowledge": {
     "domain_expertise": [
       "Integration testing frameworks and methodologies",

claude_mpm/agents/templates/version_control.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "1.2.0",
   "agent_id": "version_control_agent",
-  "agent_version": "1.1.0",
+  "agent_version": "1.3.0",
   "agent_type": "version_control",
   "metadata": {
     "name": "Version Control Agent",
@@ -19,7 +19,7 @@
     "updated_at": "2025-07-27T03:45:51.494067Z"
   },
   "capabilities": {
-    "model": "claude-sonnet-4-20250514",
+    "model": "claude-3-5-sonnet-20241022",
     "tools": [
       "Read",
       "Bash",
@@ -44,7 +44,7 @@
       ]
     }
   },
-  "instructions": "# Version Control Agent\n\nManage all git operations, versioning, and release coordination. Maintain clean history and consistent versioning.\n\n## Memory Integration and Learning\n\n### Memory Usage Protocol\n**ALWAYS review your agent memory at the start of each task.** Your accumulated knowledge helps you:\n- Apply proven git workflows and branching strategies\n- Avoid previously identified versioning mistakes and conflicts\n- Leverage successful release coordination approaches\n- Reference project-specific commit message and branching standards\n- Build upon established conflict resolution patterns\n\n### Adding Memories During Tasks\nWhen you discover valuable insights, patterns, or solutions, add them to memory using:\n\n```markdown\n# Add To Memory:\nType: [pattern|architecture|guideline|mistake|strategy|integration|performance|context]\nContent: [Your learning in 5-100 characters]\n#\n```\n\n### Version Control Memory Categories\n\n**Pattern Memories** (Type: pattern):\n- Git workflow patterns that improved team collaboration\n- Commit message patterns and conventions\n- Branching patterns for different project types\n- Merge and rebase patterns for clean history\n\n**Strategy Memories** (Type: strategy):\n- Effective approaches to complex merge conflicts\n- Release coordination strategies across teams\n- Version bumping strategies for different change types\n- Hotfix and emergency release strategies\n\n**Guideline Memories** (Type: guideline):\n- Project-specific commit message formats\n- Branch naming conventions and policies\n- Code review and approval requirements\n- Release notes and changelog standards\n\n**Mistake Memories** (Type: mistake):\n- Common merge conflicts and their resolution approaches\n- Versioning mistakes that caused deployment issues\n- Git operations that corrupted repository history\n- Release coordination failures and their prevention\n\n**Architecture Memories** (Type: architecture):\n- Repository structures that scaled well\n- Monorepo vs multi-repo decision factors\n- Git hook configurations and automation\n- CI/CD integration patterns with version control\n\n**Integration Memories** (Type: integration):\n- CI/CD pipeline integrations with git workflows\n- Issue tracker integrations with commits and PRs\n- Deployment automation triggered by version tags\n- Code quality tool integrations with git hooks\n\n**Context Memories** (Type: context):\n- Current project versioning scheme and rationale\n- Team git workflow preferences and constraints\n- Release schedule and deployment cadence\n- Compliance and audit requirements for changes\n\n**Performance Memories** (Type: performance):\n- Git operations that improved repository performance\n- Large file handling strategies (Git LFS)\n- Repository cleanup and optimization techniques\n- Efficient branching strategies for large teams\n\n### Memory Application Examples\n\n**Before creating a release:**\n```\nReviewing my strategy memories for similar release types...\nApplying guideline memory: \"Use conventional commits for automatic changelog\"\nAvoiding mistake memory: \"Don't merge feature branches directly to main\"\n```\n\n**When resolving merge conflicts:**\n```\nApplying pattern memory: \"Use three-way merge for complex conflicts\"\nFollowing strategy memory: \"Test thoroughly after conflict resolution\"\n```\n\n**During repository maintenance:**\n```\nApplying performance memory: \"Use git gc and git prune for large repos\"\nFollowing architecture memory: \"Archive old branches after 6 months\"\n```\n\n## Version Control Protocol\n1. **Git Operations**: Execute precise git commands with proper commit messages\n2. **Version Management**: Apply semantic versioning consistently\n3. **Release Coordination**: Manage release processes with proper tagging\n4. **Conflict Resolution**: Resolve merge conflicts safely\n5. **Memory Application**: Apply lessons learned from previous version control work\n\n## Versioning Focus\n- Semantic versioning (MAJOR.MINOR.PATCH) enforcement\n- Clean git history with meaningful commits\n- Coordinated release management",
+  "instructions": "# Version Control Agent\n\nManage all git operations, versioning, and release coordination. Maintain clean history and consistent versioning.\n\n## Memory Integration and Learning\n\n### Memory Usage Protocol\n**ALWAYS review your agent memory at the start of each task.** Your accumulated knowledge helps you:\n- Apply proven git workflows and branching strategies\n- Avoid previously identified versioning mistakes and conflicts\n- Leverage successful release coordination approaches\n- Reference project-specific commit message and branching standards\n- Build upon established conflict resolution patterns\n\n### Adding Memories During Tasks\nWhen you discover valuable insights, patterns, or solutions, add them to memory using:\n\n```markdown\n# Add To Memory:\nType: [pattern|architecture|guideline|mistake|strategy|integration|performance|context]\nContent: [Your learning in 5-100 characters]\n#\n```\n\n### Version Control Memory Categories\n\n**Pattern Memories** (Type: pattern):\n- Git workflow patterns that improved team collaboration\n- Commit message patterns and conventions\n- Branching patterns for different project types\n- Merge and rebase patterns for clean history\n\n**Strategy Memories** (Type: strategy):\n- Effective approaches to complex merge conflicts\n- Release coordination strategies across teams\n- Version bumping strategies for different change types\n- Hotfix and emergency release strategies\n\n**Guideline Memories** (Type: guideline):\n- Project-specific commit message formats\n- Branch naming conventions and policies\n- Code review and approval requirements\n- Release notes and changelog standards\n\n**Mistake Memories** (Type: mistake):\n- Common merge conflicts and their resolution approaches\n- Versioning mistakes that caused deployment issues\n- Git operations that corrupted repository history\n- Release coordination failures and their prevention\n\n**Architecture Memories** (Type: architecture):\n- Repository structures that scaled well\n- Monorepo vs multi-repo decision factors\n- Git hook configurations and automation\n- CI/CD integration patterns with version control\n\n**Integration Memories** (Type: integration):\n- CI/CD pipeline integrations with git workflows\n- Issue tracker integrations with commits and PRs\n- Deployment automation triggered by version tags\n- Code quality tool integrations with git hooks\n\n**Context Memories** (Type: context):\n- Current project versioning scheme and rationale\n- Team git workflow preferences and constraints\n- Release schedule and deployment cadence\n- Compliance and audit requirements for changes\n\n**Performance Memories** (Type: performance):\n- Git operations that improved repository performance\n- Large file handling strategies (Git LFS)\n- Repository cleanup and optimization techniques\n- Efficient branching strategies for large teams\n\n### Memory Application Examples\n\n**Before creating a release:**\n```\nReviewing my strategy memories for similar release types...\nApplying guideline memory: \"Use conventional commits for automatic changelog\"\nAvoiding mistake memory: \"Don't merge feature branches directly to main\"\n```\n\n**When resolving merge conflicts:**\n```\nApplying pattern memory: \"Use three-way merge for complex conflicts\"\nFollowing strategy memory: \"Test thoroughly after conflict resolution\"\n```\n\n**During repository maintenance:**\n```\nApplying performance memory: \"Use git gc and git prune for large repos\"\nFollowing architecture memory: \"Archive old branches after 6 months\"\n```\n\n## Version Control Protocol\n1. **Git Operations**: Execute precise git commands with proper commit messages\n2. **Version Management**: Apply semantic versioning consistently\n3. **Release Coordination**: Manage release processes with proper tagging\n4. **Conflict Resolution**: Resolve merge conflicts safely\n5. **Memory Application**: Apply lessons learned from previous version control work\n\n## Versioning Focus\n- Semantic versioning (MAJOR.MINOR.PATCH) enforcement\n- Clean git history with meaningful commits\n- Coordinated release management\n\n## TodoWrite Usage Guidelines\n\nWhen using TodoWrite, always prefix tasks with your agent name to maintain clear ownership and coordination:\n\n### Required Prefix Format\n- ✅ `[Version Control] Create release branch for version 2.1.0 deployment`\n- ✅ `[Version Control] Merge feature branch with squash commit strategy`\n- ✅ `[Version Control] Tag stable release and push to remote repository`\n- ✅ `[Version Control] Resolve merge conflicts in authentication module`\n- ❌ Never use generic todos without agent prefix\n- ❌ Never use another agent's prefix (e.g., [Engineer], [Documentation])\n\n### Task Status Management\nTrack your version control progress systematically:\n- **pending**: Git operation not yet started\n- **in_progress**: Currently executing git commands or coordination (mark when you begin work)\n- **completed**: Version control task completed successfully\n- **BLOCKED**: Stuck on merge conflicts or approval dependencies (include reason)\n\n### Version Control-Specific Todo Patterns\n\n**Branch Management Tasks**:\n- `[Version Control] Create feature branch for user authentication implementation`\n- `[Version Control] Merge hotfix branch to main and develop branches`\n- `[Version Control] Delete stale feature branches after successful deployment`\n- `[Version Control] Rebase feature branch on latest main branch changes`\n\n**Release Management Tasks**:\n- `[Version Control] Prepare release candidate with version bump to 2.1.0-rc1`\n- `[Version Control] Create and tag stable release v2.1.0 from release branch`\n- `[Version Control] Generate release notes and changelog for version 2.1.0`\n- `[Version Control] Coordinate deployment timing with ops team`\n\n**Repository Maintenance Tasks**:\n- `[Version Control] Clean up merged branches and optimize repository size`\n- `[Version Control] Update .gitignore to exclude new build artifacts`\n- `[Version Control] Configure branch protection rules for main branch`\n- `[Version Control] Archive old releases and maintain repository history`\n\n**Conflict Resolution Tasks**:\n- `[Version Control] Resolve merge conflicts in database migration files`\n- `[Version Control] Coordinate with engineers to resolve code conflicts`\n- `[Version Control] Validate merge resolution preserves all functionality`\n- `[Version Control] Test merged code before pushing to shared branches`\n\n### Special Status Considerations\n\n**For Complex Release Coordination**:\nBreak release management into coordinated phases:\n```\n[Version Control] Coordinate v2.1.0 release deployment\n├── [Version Control] Prepare release branch and version tags (completed)\n├── [Version Control] Coordinate with QA for release testing (in_progress)\n├── [Version Control] Schedule deployment window with ops (pending)\n└── [Version Control] Post-release branch cleanup and archival (pending)\n```\n\n**For Blocked Version Control Operations**:\nAlways include the blocking reason and impact assessment:\n- `[Version Control] Merge payment feature (BLOCKED - merge conflicts in core auth module)`\n- `[Version Control] Tag release v2.0.5 (BLOCKED - waiting for final QA sign-off)`\n- `[Version Control] Push hotfix to production (BLOCKED - pending security review approval)`\n\n**For Emergency Hotfix Coordination**:\nPrioritize and track urgent fixes:\n- `[Version Control] URGENT: Create hotfix branch for critical security vulnerability`\n- `[Version Control] URGENT: Fast-track merge and deploy auth bypass fix`\n- `[Version Control] URGENT: Coordinate immediate rollback if deployment fails`\n\n### Version Control Standards and Practices\nAll version control todos should adhere to:\n- **Semantic Versioning**: Follow MAJOR.MINOR.PATCH versioning scheme\n- **Conventional Commits**: Use structured commit messages for automatic changelog generation\n- **Branch Naming**: Use consistent naming conventions (feature/, hotfix/, release/)\n- **Merge Strategy**: Specify merge strategy (squash, rebase, merge commit)\n\n### Git Operation Documentation\nInclude specific git commands and rationale:\n- `[Version Control] Execute git rebase -i to clean up commit history before merge`\n- `[Version Control] Use git cherry-pick to apply specific fixes to release branch`\n- `[Version Control] Create signed tags with GPG for security compliance`\n- `[Version Control] Configure git hooks for automated testing and validation`\n\n### Coordination with Other Agents\n- Reference specific code changes when coordinating merges with engineering teams\n- Include deployment timeline requirements when coordinating with ops agents\n- Note documentation update needs when coordinating release communications\n- Update todos immediately when version control operations affect other agents\n- Use clear branch names and commit messages that help other agents understand changes",
   "knowledge": {
     "domain_expertise": [
       "Git workflows and best practices",

claude_mpm/services/agent_deployment.py

@@ -186,6 +186,7 @@ class AgentDeploymentService:
             "skipped": [],
             "updated": [],
             "migrated": [],  # Track agents migrated from old format
+            "converted": [],  # Track YAML to MD conversions
             "total": 0,
             # METRICS: Add detailed timing and performance data to results
             "metrics": {
@@ -212,6 +213,10 @@ class AgentDeploymentService:
                 results["errors"].append(error_msg)
                 return results
             
+            # Convert any existing YAML files to MD format
+            conversion_results = self._convert_yaml_to_md(target_dir)
+            results["converted"] = conversion_results.get("converted", [])
+            
             # Load base agent content
             # OPERATIONAL NOTE: Base agent contains shared configuration and instructions
             # that all agents inherit. This reduces duplication and ensures consistency.
@@ -242,7 +247,7 @@ class AgentDeploymentService:
                     agent_start_time = time.time()
                     
                     agent_name = template_file.stem
-                    target_file = target_dir / f"{agent_name}.yaml"
+                    target_file = target_dir / f"{agent_name}.md"
                     
                     # Check if agent needs update
                     needs_update = force_rebuild
@@ -265,12 +270,12 @@ class AgentDeploymentService:
                         self.logger.debug(f"Skipped up-to-date agent: {agent_name}")
                         continue
                     
-                    # Build the agent file
-                    agent_yaml = self._build_agent_yaml(agent_name, template_file, base_agent_data)
+                    # Build the agent file as markdown with YAML frontmatter
+                    agent_content = self._build_agent_markdown(agent_name, template_file, base_agent_data)
                     
                     # Write the agent file
                     is_update = target_file.exists()
-                    target_file.write_text(agent_yaml)
+                    target_file.write_text(agent_content)
                     
                     # METRICS: Record deployment time for this agent
                     agent_deployment_time = (time.time() - agent_start_time) * 1000  # Convert to ms
@@ -320,6 +325,7 @@ class AgentDeploymentService:
                 f"Deployed {len(results['deployed'])} agents, "
                 f"updated {len(results['updated'])}, "
                 f"migrated {len(results['migrated'])}, "
+                f"converted {len(results['converted'])} YAML files, "
                 f"skipped {len(results['skipped'])}, "
                 f"errors: {len(results['errors'])}"
             )
@@ -514,6 +520,13 @@ class AgentDeploymentService:
             ["Read", "Write", "Edit", "Grep", "Glob", "LS"]  # Default fallback
         )
         
+        # Get model from capabilities.model in new format
+        model = (
+            template_data.get('capabilities', {}).get('model') or
+            template_data.get('configuration_fields', {}).get('model') or
+            "claude-sonnet-4-20250514"  # Default fallback
+        )
+        
         frontmatter = f"""---
 name: {agent_name}
 description: "{description}"
@@ -523,6 +536,7 @@ created: "{datetime.now().isoformat()}Z"
 updated: "{datetime.now().isoformat()}Z"
 tags: {tags}
 tools: {tools}
+model: "{model}"
 metadata:
   base_version: "{self._format_version_display(base_version)}"
   agent_version: "{self._format_version_display(agent_version)}"
@@ -848,7 +862,7 @@ temperature: {temperature}"""
             return results
         
         # List deployed agents
-        agent_files = list(agents_dir.glob("*.yaml"))
+        agent_files = list(agents_dir.glob("*.md"))
         for agent_file in agent_files:
             try:
                 # Read first few lines to get agent name from YAML
@@ -1101,7 +1115,7 @@ temperature: {temperature}"""
             return results
         
         # Remove system agents only (identified by claude-mpm author)
-        agent_files = list(agents_dir.glob("*.yaml"))
+        agent_files = list(agents_dir.glob("*.md"))
         
         for agent_file in agent_files:
             try:
@@ -1531,4 +1545,212 @@ temperature: {temperature}"""
         except Exception as e:
             error_msg = f"Failed to deploy system instructions: {e}"
             self.logger.error(error_msg)
-            results["errors"].append(error_msg)
+            results["errors"].append(error_msg)
+    
+    def _convert_yaml_to_md(self, target_dir: Path) -> Dict[str, Any]:
+        """
+        Convert existing YAML agent files to MD format with YAML frontmatter.
+        
+        This method handles backward compatibility by finding existing .yaml
+        agent files and converting them to .md format expected by Claude Code.
+        
+        Args:
+            target_dir: Directory containing agent files
+            
+        Returns:
+            Dictionary with conversion results:
+            - converted: List of converted files
+            - errors: List of conversion errors
+            - skipped: List of files that didn't need conversion
+        """
+        results = {
+            "converted": [],
+            "errors": [],
+            "skipped": []
+        }
+        
+        try:
+            # Find existing YAML agent files
+            yaml_files = list(target_dir.glob("*.yaml"))
+            
+            if not yaml_files:
+                self.logger.debug("No YAML files found to convert")
+                return results
+            
+            self.logger.info(f"Found {len(yaml_files)} YAML files to convert to MD format")
+            
+            for yaml_file in yaml_files:
+                try:
+                    agent_name = yaml_file.stem
+                    md_file = target_dir / f"{agent_name}.md"
+                    
+                    # Skip if MD file already exists (unless it's older than YAML)
+                    if md_file.exists():
+                        # Check modification times for safety
+                        yaml_mtime = yaml_file.stat().st_mtime
+                        md_mtime = md_file.stat().st_mtime
+                        
+                        if md_mtime >= yaml_mtime:
+                            results["skipped"].append({
+                                "yaml_file": str(yaml_file),
+                                "md_file": str(md_file),
+                                "reason": "MD file already exists and is newer"
+                            })
+                            continue
+                        else:
+                            # MD file is older, proceed with conversion
+                            self.logger.info(f"MD file {md_file.name} is older than YAML, converting...")
+                    
+                    # Read YAML content
+                    yaml_content = yaml_file.read_text()
+                    
+                    # Convert YAML to MD with YAML frontmatter
+                    md_content = self._convert_yaml_content_to_md(yaml_content, agent_name)
+                    
+                    # Write MD file
+                    md_file.write_text(md_content)
+                    
+                    # Create backup of YAML file before removing (for safety)
+                    backup_file = target_dir / f"{agent_name}.yaml.backup"
+                    try:
+                        yaml_file.rename(backup_file)
+                        self.logger.debug(f"Created backup: {backup_file.name}")
+                    except Exception as backup_error:
+                        self.logger.warning(f"Failed to create backup for {yaml_file.name}: {backup_error}")
+                        # Still remove the original YAML file even if backup fails
+                        yaml_file.unlink()
+                    
+                    results["converted"].append({
+                        "from": str(yaml_file),
+                        "to": str(md_file),
+                        "agent": agent_name
+                    })
+                    
+                    self.logger.info(f"Converted {yaml_file.name} to {md_file.name}")
+                    
+                except Exception as e:
+                    error_msg = f"Failed to convert {yaml_file.name}: {e}"
+                    self.logger.error(error_msg)
+                    results["errors"].append(error_msg)
+            
+        except Exception as e:
+            error_msg = f"YAML to MD conversion failed: {e}"
+            self.logger.error(error_msg)
+            results["errors"].append(error_msg)
+        
+        return results
+    
+    def _convert_yaml_content_to_md(self, yaml_content: str, agent_name: str) -> str:
+        """
+        Convert YAML agent content to MD format with YAML frontmatter.
+        
+        Args:
+            yaml_content: Original YAML content
+            agent_name: Name of the agent
+            
+        Returns:
+            Markdown content with YAML frontmatter
+        """
+        import re
+        from datetime import datetime
+        
+        # Extract YAML frontmatter and content
+        yaml_parts = yaml_content.split('---', 2)
+        
+        if len(yaml_parts) < 3:
+            # No proper YAML frontmatter, treat entire content as instructions
+            frontmatter = f"""---
+name: {agent_name}
+description: "Agent for specialized tasks"
+version: "1.0.0"
+author: "claude-mpm@anthropic.com"
+created: "{datetime.now().isoformat()}Z"
+updated: "{datetime.now().isoformat()}Z"
+tags: ["{agent_name}", "mpm-framework"]
+tools: ["Read", "Write", "Edit", "Grep", "Glob", "LS"]
+metadata:
+  deployment_type: "system"
+  converted_from: "yaml"
+---
+
+"""
+            return frontmatter + yaml_content.strip()
+        
+        # Parse existing frontmatter
+        yaml_frontmatter = yaml_parts[1].strip()
+        instructions = yaml_parts[2].strip()
+        
+        # Extract key fields from YAML frontmatter
+        name = agent_name
+        description = self._extract_yaml_field(yaml_frontmatter, 'description') or f"{agent_name.title()} agent for specialized tasks"
+        version = self._extract_yaml_field(yaml_frontmatter, 'version') or "1.0.0"
+        tools_line = self._extract_yaml_field(yaml_frontmatter, 'tools') or "Read, Write, Edit, Grep, Glob, LS"
+        
+        # Convert tools string to list format
+        if isinstance(tools_line, str):
+            if tools_line.startswith('[') and tools_line.endswith(']'):
+                # Already in list format
+                tools_list = tools_line
+            else:
+                # Convert comma-separated to list
+                tools = [tool.strip() for tool in tools_line.split(',')]
+                tools_list = str(tools)
+        else:
+            tools_list = str(tools_line) if tools_line else '["Read", "Write", "Edit", "Grep", "Glob", "LS"]'
+        
+        # Build new YAML frontmatter
+        new_frontmatter = f"""---
+name: {name}
+description: "{description}"
+version: "{version}"
+author: "claude-mpm@anthropic.com"
+created: "{datetime.now().isoformat()}Z"
+updated: "{datetime.now().isoformat()}Z"
+tags: ["{agent_name}", "mpm-framework"]
+tools: {tools_list}
+metadata:
+  deployment_type: "system"
+  converted_from: "yaml"
+---
+
+"""
+        
+        return new_frontmatter + instructions
+    
+    def _extract_yaml_field(self, yaml_content: str, field_name: str) -> str:
+        """
+        Extract a field value from YAML content.
+        
+        Args:
+            yaml_content: YAML content string
+            field_name: Field name to extract
+            
+        Returns:
+            Field value or None if not found
+        """
+        import re
+        
+        try:
+            # Match field with quoted or unquoted values
+            pattern = rf'^{field_name}:\s*["\']?(.*?)["\']?\s*$'
+            match = re.search(pattern, yaml_content, re.MULTILINE)
+            
+            if match:
+                return match.group(1).strip()
+            
+            # Try with alternative spacing patterns
+            pattern = rf'^{field_name}\s*:\s*(.+)$'
+            match = re.search(pattern, yaml_content, re.MULTILINE)
+            
+            if match:
+                value = match.group(1).strip()
+                # Remove quotes if present
+                if (value.startswith('"') and value.endswith('"')) or \
+                   (value.startswith("'") and value.endswith("'")):
+                    value = value[1:-1]
+                return value
+                
+        except Exception as e:
+            self.logger.warning(f"Error extracting YAML field '{field_name}': {e}")
+        
+        return None

claude_mpm/services/agent_profile_loader.py

@@ -264,7 +264,11 @@ class AgentProfileLoader(BaseService):
         tier_path = self.tier_paths[tier]
         
         # Try different file formats and naming conventions
+        # Check .md files first (Claude Code format), then fall back to YAML/JSON
         possible_files = [
+            tier_path / f"{agent_name}.md",
+            tier_path / f"{agent_name}_agent.md",
+            tier_path / f"{agent_name}-agent.md",
             tier_path / f"{agent_name}.yaml",
             tier_path / f"{agent_name}.yml",
             tier_path / f"{agent_name}.json",
@@ -290,16 +294,23 @@ class AgentProfileLoader(BaseService):
             content = file_path.read_text()
             
             # Parse based on file extension
-            if file_path.suffix in ['.yaml', '.yml']:
+            if file_path.suffix == '.md':
+                # Parse markdown with YAML frontmatter
+                data, instructions = self._parse_markdown_with_frontmatter(content)
+            elif file_path.suffix in ['.yaml', '.yml']:
                 data = yaml.safe_load(content)
+                instructions = data.get('instructions', '')
             elif file_path.suffix == '.json':
                 data = json.loads(content)
+                instructions = data.get('instructions', '')
             else:
                 # Try to parse as YAML first, then JSON
                 try:
                     data = yaml.safe_load(content)
+                    instructions = data.get('instructions', '')
                 except:
                     data = json.loads(content)
+                    instructions = data.get('instructions', '')
             
             # Create profile
             profile = AgentProfile(
@@ -308,7 +319,7 @@ class AgentProfileLoader(BaseService):
                 description=data.get('description', ''),
                 tier=tier,
                 source_path=str(file_path),
-                instructions=data.get('instructions', ''),
+                instructions=instructions,
                 capabilities=data.get('capabilities', []),
                 constraints=data.get('constraints', []),
                 metadata=data.get('metadata', {}),
@@ -329,6 +340,44 @@ class AgentProfileLoader(BaseService):
                 error=str(e)
             )
     
+    def _parse_markdown_with_frontmatter(self, content: str) -> Tuple[Dict[str, Any], str]:
+        """
+        Parse markdown file with YAML frontmatter.
+        
+        Args:
+            content: Markdown content with YAML frontmatter
+            
+        Returns:
+            Tuple of (frontmatter_data, markdown_content)
+        """
+        import re
+        
+        # Check if content starts with YAML frontmatter
+        if not content.strip().startswith('---'):
+            # No frontmatter, treat entire content as instructions
+            return {'name': 'unknown', 'description': 'No frontmatter found'}, content
+        
+        # Split frontmatter and content
+        parts = re.split(r'^---\s*$', content, 2, re.MULTILINE)
+        
+        if len(parts) < 3:
+            # Invalid frontmatter structure
+            return {'name': 'unknown', 'description': 'Invalid frontmatter'}, content
+        
+        # Parse YAML frontmatter
+        frontmatter_text = parts[1].strip()
+        markdown_content = parts[2].strip()
+        
+        try:
+            frontmatter_data = yaml.safe_load(frontmatter_text)
+            if not isinstance(frontmatter_data, dict):
+                frontmatter_data = {'name': 'unknown', 'description': 'Invalid frontmatter format'}
+        except Exception as e:
+            logger.error(f"Error parsing YAML frontmatter: {e}")
+            frontmatter_data = {'name': 'unknown', 'description': f'YAML parse error: {e}'}
+        
+        return frontmatter_data, markdown_content
+    
     # ========================================================================
     # Profile Discovery
     # ========================================================================
@@ -342,16 +391,19 @@ class AgentProfileLoader(BaseService):
                 continue
                 
             agents = []
-            for file_path in tier_path.glob('*.{yaml,yml,json}'):
-                agent_name = file_path.stem
-                # Remove common suffixes
-                if agent_name.endswith('_agent'):
-                    agent_name = agent_name[:-6]
-                elif agent_name.endswith('-agent'):
-                    agent_name = agent_name[:-6]
-                
-                if agent_name not in agents:
-                    agents.append(agent_name)
+            # Check for .md files (Claude Code format) and YAML/JSON files
+            file_patterns = ['*.md', '*.yaml', '*.yml', '*.json']
+            for pattern in file_patterns:
+                for file_path in tier_path.glob(pattern):
+                    agent_name = file_path.stem
+                    # Remove common suffixes
+                    if agent_name.endswith('_agent'):
+                        agent_name = agent_name[:-6]
+                    elif agent_name.endswith('-agent'):
+                        agent_name = agent_name[:-6]
+                    
+                    if agent_name not in agents:
+                        agents.append(agent_name)
             
             discovered[tier] = agents
             logger.debug(f"Discovered {len(agents)} agents in {tier.value} tier")

claude_mpm/services/agent_registry.py

@@ -294,19 +294,50 @@ class AgentRegistry:
         try:
             content = file_path.read_text()
             
-            # Try to parse as JSON/YAML for structured data
-            if file_path.suffix in ['.json', '.yaml', '.yml']:
+            # Try to parse as JSON/YAML/MD for structured data
+            if file_path.suffix in ['.md', '.json', '.yaml', '.yml']:
                 try:
                     if file_path.suffix == '.json':
                         data = json.loads(content)
+                        description = data.get('description', '')
+                        version = data.get('version', '0.0.0')
+                        capabilities = data.get('capabilities', [])
+                        metadata = data.get('metadata', {})
+                    elif file_path.suffix == '.md':
+                        # Parse markdown with YAML frontmatter
+                        import yaml
+                        import re
+                        
+                        # Check for YAML frontmatter
+                        if content.strip().startswith('---'):
+                            parts = re.split(r'^---\s*$', content, 2, re.MULTILINE)
+                            if len(parts) >= 3:
+                                frontmatter_text = parts[1].strip()
+                                data = yaml.safe_load(frontmatter_text)
+                                description = data.get('description', '')
+                                version = data.get('version', '0.0.0')
+                                capabilities = data.get('tools', [])  # Tools in .md format
+                                metadata = data.get('metadata', {})
+                            else:
+                                # No frontmatter, use defaults
+                                description = f"{file_path.stem} agent"
+                                version = '1.0.0'
+                                capabilities = []
+                                metadata = {}
+                        else:
+                            # No frontmatter, use defaults
+                            description = f"{file_path.stem} agent"
+                            version = '1.0.0'
+                            capabilities = []
+                            metadata = {}
                     else:
+                        # YAML files
                         import yaml
                         data = yaml.safe_load(content)
-                    
-                    description = data.get('description', '')
-                    version = data.get('version', '0.0.0')
-                    capabilities = data.get('capabilities', [])
-                    metadata = data.get('metadata', {})
+                        description = data.get('description', '')
+                        version = data.get('version', '0.0.0')
+                        capabilities = data.get('capabilities', [])
+                        metadata = data.get('metadata', {})
                 except Exception:
                     pass
             

{claude_mpm-3.4.20.dist-info → claude_mpm-3.4.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.4.20
+Version: 3.4.24
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team
@@ -36,6 +36,7 @@ Requires-Dist: python-socketio>=5.11.0
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: aiohttp-cors>=0.8.0
 Requires-Dist: python-engineio>=4.8.0
+Requires-Dist: urwid>=2.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"