claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -31,6 +31,7 @@ import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
+from claude_mpm.config.agent_sources import AgentSourceConfiguration
 from claude_mpm.config.paths import paths
 from claude_mpm.constants import Paths
 from claude_mpm.core.config import Config
@@ -38,6 +39,8 @@ from claude_mpm.core.exceptions import AgentDeploymentError
 from claude_mpm.core.interfaces import AgentDeploymentInterface
 from claude_mpm.services.shared import ConfigServiceBase
 
+# Import git source management for remote agent sync
+from ..git_source_manager import GitSourceManager
 from .agent_configuration_manager import AgentConfigurationManager
 from .agent_discovery_service import AgentDiscoveryService
 from .agent_environment_manager import AgentEnvironmentManager
@@ -184,9 +187,110 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
         # Initialize format converter service
         self.format_converter = AgentFormatConverter()
 
+        # Initialize git source manager for remote agent sync
+        self.git_source_manager = GitSourceManager()
+        self.agent_source_config = AgentSourceConfiguration.load()
+
         self.logger.info(f"Templates directory: {self.templates_dir}")
         self.logger.info(f"Base agent path: {self.base_agent_path}")
 
+    def _sync_remote_agent_sources(self, timeout_seconds: int = 30) -> Dict[str, Any]:
+        """Sync git-based agent sources before deployment.
+
+        This method follows the skills system pattern: sync configured git repositories
+        to cache before discovery. Network failures are logged but don't block deployment.
+
+        Args:
+            timeout_seconds: Timeout for git operations (default: 30 seconds)
+
+        Returns:
+            Dictionary with sync results:
+            {
+                "synced_count": int,
+                "failed_count": int,
+                "repositories": Dict[str, Dict],  # repo_id -> sync result
+                "duration_ms": float
+            }
+
+        Error Handling:
+            - Network failures: Logged as warnings, sync continues
+            - Invalid repos: Logged as errors, sync continues
+            - Timeout: Individual repo timeouts don't stop overall sync
+            - Missing cache dir: Created automatically
+        """
+        import time
+
+        start_time = time.time()
+
+        results = {
+            "synced_count": 0,
+            "failed_count": 0,
+            "repositories": {},
+            "duration_ms": 0,
+        }
+
+        # Load agent sources configuration
+        try:
+            config = AgentSourceConfiguration.load()
+            enabled_repos = [r for r in config.repositories if r.enabled]
+
+            if not enabled_repos:
+                self.logger.debug("No enabled agent sources configured")
+                return results
+
+            self.logger.info(f"Syncing {len(enabled_repos)} agent git sources...")
+
+            # Sync each enabled repository
+            for repo in enabled_repos:
+                repo_id = repo.identifier
+                try:
+                    # Sync with timeout (individual repo sync)
+                    # NOTE: show_progress=False to avoid duplicate progress bars
+                    # (startup sync already showed progress to user)
+                    sync_result = self.git_source_manager.sync_repository(
+                        repo,
+                        force=False,  # Use ETag-based caching
+                        show_progress=False,  # Suppress progress (startup already synced)
+                    )
+
+                    results["repositories"][repo_id] = sync_result
+
+                    if sync_result.get("synced"):
+                        results["synced_count"] += 1
+                        agents_discovered = sync_result.get("agents_discovered", [])
+                        self.logger.info(
+                            f"Synced {repo_id}: {sync_result.get('files_updated', 0)} files, "
+                            f"{len(agents_discovered)} agents"
+                        )
+                    else:
+                        results["failed_count"] += 1
+                        error = sync_result.get("error", "Unknown error")
+                        self.logger.warning(f"Failed to sync {repo_id}: {error}")
+
+                except Exception as e:
+                    # Don't let individual repo failures stop deployment
+                    results["failed_count"] += 1
+                    results["repositories"][repo_id] = {
+                        "synced": False,
+                        "error": str(e),
+                    }
+                    self.logger.warning(f"Exception syncing {repo_id}: {e}")
+
+        except Exception as e:
+            # Configuration loading failure - log but don't crash
+            self.logger.warning(f"Failed to load agent sources config: {e}")
+            results["failed_count"] = -1  # Indicates config failure
+
+        results["duration_ms"] = (time.time() - start_time) * 1000
+
+        if results["synced_count"] > 0:
+            self.logger.info(
+                f"Agent source sync complete: {results['synced_count']} succeeded, "
+                f"{results['failed_count']} failed ({results['duration_ms']:.0f}ms)"
+            )
+
+        return results
+
     def deploy_agents(
         self,
         target_dir: Optional[Path] = None,
@@ -267,6 +371,10 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
         # METRICS: Record deployment start time for performance tracking
         deployment_start_time = time.time()
 
+        # PHASE 2 (1M-442): Sync git-based agent sources before deployment
+        # This ensures remote agents from configured sources are cached and discoverable
+        sync_results = self._sync_remote_agent_sources()
+
         # Try async deployment for better performance if requested
         if use_async:
             async_results = self._try_async_deployment(
@@ -292,6 +400,13 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
             agents_dir, deployment_start_time
         )
 
+        # Add git source sync results to deployment results
+        if (
+            sync_results.get("synced_count", 0) > 0
+            or sync_results.get("failed_count", 0) > 0
+        ):
+            results["remote_sources"] = sync_results
+
         try:
             # Create agents directory if needed
             agents_dir.mkdir(parents=True, exist_ok=True)
@@ -369,12 +484,18 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                     else "single"
                 )
 
+                # When using multi-source deployment, we've already determined which
+                # agents need updates. Don't re-check versions in single_agent_deployer.
+                # This prevents the issue where multi-source says "deploying 9 agents"
+                # but then all get skipped due to redundant version checks.
+                skip_version_check = use_multi_source and not force_rebuild
+
                 self.single_agent_deployer.deploy_single_agent(
                     template_file=template_file_path,
                     agents_dir=agents_dir,
                     base_agent_data=base_agent_data,
                     base_agent_version=base_agent_version,
-                    force_rebuild=force_rebuild,
+                    force_rebuild=force_rebuild or skip_version_check,
                     deployment_mode=deployment_mode,
                     results=results,
                     source_info=source_info,
@@ -683,7 +804,10 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
 
     def _get_filtered_templates(self, excluded_agents: list, config: Config) -> list:
         """Get and filter template files based on exclusion rules."""
-        return self.discovery_service.get_filtered_templates(excluded_agents, config)
+        filter_non_mpm = config.get("agent_deployment.filter_non_mpm_agents", True)
+        return self.discovery_service.get_filtered_templates(
+            excluded_agents, config, filter_non_mpm
+        )
 
     def _validate_and_repair_existing_agents(self, agents_dir: Path) -> Dict[str, Any]:
         """Validate and repair broken frontmatter in existing agent files."""
@@ -745,19 +869,28 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                 project_agents_dir = potential_project_dir
                 self.logger.info(f"Found project agents at: {project_agents_dir}")
 
-        # Check for user agents
+        # Check for user agents (DEPRECATED)
         user_home = Path.home()
         potential_user_dir = user_home / ".claude-mpm" / "agents"
         if potential_user_dir.exists():
             user_agents_dir = potential_user_dir
             self.logger.info(f"Found user agents at: {user_agents_dir}")
 
-        # Get agents with version comparison and cleanup
+        # Check for remote agents (cached from GitHub)
+        remote_agents_dir = None
+        cache_dir = user_home / ".claude-mpm" / "cache"
+        potential_remote_dir = cache_dir / "remote-agents"
+        if potential_remote_dir.exists():
+            remote_agents_dir = potential_remote_dir
+            self.logger.info(f"Found remote agents cache at: {remote_agents_dir}")
+
+        # Get agents with version comparison and cleanup (4-tier discovery)
         agents_to_deploy, agent_sources, cleanup_results = (
             self.multi_source_service.get_agents_for_deployment(
                 system_templates_dir=system_templates_dir,
                 project_agents_dir=project_agents_dir,
                 user_agents_dir=user_agents_dir,
+                remote_agents_dir=remote_agents_dir,  # NEW: 4th tier
                 working_directory=self.working_directory,
                 excluded_agents=excluded_agents,
                 config=config,
@@ -773,16 +906,6 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                 agent_sources=agent_sources,
             )
 
-            # Log version upgrades and source changes
-            if comparison_results.get("version_upgrades"):
-                self.logger.info(
-                    f"Version upgrades available for {len(comparison_results['version_upgrades'])} agents"
-                )
-            if comparison_results.get("source_changes"):
-                self.logger.info(
-                    f"Source changes for {len(comparison_results['source_changes'])} agents"
-                )
-
             # Filter agents based on comparison results (unless force_rebuild is set)
             if not force_rebuild:
                 # Only deploy agents that need updates or are new
@@ -801,11 +924,35 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                     for name, path in agents_to_deploy.items()
                     if name in agents_needing_update
                 }
+
+                # Only log upgrade messages if we're actually going to deploy them
+                if filtered_agents and comparison_results.get("version_upgrades"):
+                    # Filter upgrades to only those actually being deployed
+                    deployed_upgrades = [
+                        upgrade
+                        for upgrade in comparison_results["version_upgrades"]
+                        if upgrade["name"] in filtered_agents
+                    ]
+
+                    if deployed_upgrades:
+                        self.logger.info(
+                            f"Deploying {len(deployed_upgrades)} agent upgrade(s):"
+                        )
+                        for upgrade in deployed_upgrades:
+                            self.logger.info(
+                                f"  Upgrading: {upgrade['name']} "
+                                f"{upgrade['deployed_version']} -> {upgrade['new_version']} "
+                                f"(from {upgrade['source']})"
+                            )
+
                 agents_to_deploy = filtered_agents
 
-                self.logger.info(
-                    f"Filtered to {len(agents_to_deploy)} agents needing deployment"
-                )
+                # Don't log this redundant message - we already logged the upgrades above
+                # The "Deploying X agent upgrade(s)" message is sufficient
+                if not agents_to_deploy:
+                    self.logger.debug(
+                        f"All {len(comparison_results.get('up_to_date', []))} agents are up to date"
+                    )
 
         # Convert to list of Path objects
         template_files = list(agents_to_deploy.values())

claude_mpm/services/agents/deployment/agent_discovery_service.py

@@ -7,10 +7,11 @@ Extracted from AgentDeploymentService as part of the refactoring to improve
 maintainability and testability.
 """
 
-import json
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+import yaml
+
 from claude_mpm.core.config import Config
 from claude_mpm.core.logging_config import get_logger
 
@@ -59,8 +60,8 @@ class AgentDiscoveryService:
             )
             return agents
 
-        # Find all JSON template files
-        template_files = list(self.templates_dir.glob("*.json"))
+        # Find all markdown template files with YAML frontmatter
+        template_files = list(self.templates_dir.glob("*.md"))
 
         for template_file in template_files:
             try:
@@ -85,7 +86,10 @@ class AgentDiscoveryService:
         return agents
 
     def get_filtered_templates(
-        self, excluded_agents: List[str], config: Optional[Config] = None
+        self,
+        excluded_agents: List[str],
+        config: Optional[Config] = None,
+        filter_non_mpm: bool = False,
     ) -> List[Path]:
         """
         Get filtered list of template files based on configuration.
@@ -93,6 +97,7 @@ class AgentDiscoveryService:
         Args:
             excluded_agents: List of agent names to exclude
             config: Configuration object for additional filtering
+            filter_non_mpm: Whether to filter out non-MPM agents
 
         Returns:
             List of template file paths to deploy
@@ -101,8 +106,8 @@ class AgentDiscoveryService:
             self.logger.error(f"Templates directory not found: {self.templates_dir}")
             return []
 
-        # Get all template files
-        template_files = list(self.templates_dir.glob("*.json"))
+        # Get all markdown template files
+        template_files = list(self.templates_dir.glob("*.md"))
 
         if not template_files:
             self.logger.warning(f"No agent templates found in {self.templates_dir}")
@@ -111,6 +116,7 @@ class AgentDiscoveryService:
         # Apply exclusion filtering
         filtered_files = []
         excluded_count = 0
+        non_mpm_count = 0
 
         for template_file in template_files:
             agent_name = template_file.stem
@@ -121,14 +127,24 @@ class AgentDiscoveryService:
                 self.logger.debug(f"Excluding agent: {agent_name}")
                 continue
 
+            # Check if we should filter non-MPM agents
+            if filter_non_mpm and not self._is_mpm_agent(template_file):
+                non_mpm_count += 1
+                self.logger.debug(f"Filtering non-MPM agent: {agent_name}")
+                continue
+
             # Validate template file
             if self._validate_template_file(template_file):
                 filtered_files.append(template_file)
             else:
                 self.logger.warning(f"Invalid template file: {template_file.name}")
 
+        # Log filtering results
+        if filter_non_mpm and non_mpm_count > 0:
+            self.logger.info(f"Filtered out {non_mpm_count} non-MPM agents")
+
         self.logger.info(
-            f"Found {len(template_files)} templates, excluded {excluded_count}, deploying {len(filtered_files)}"
+            f"Found {len(template_files)} templates, excluded {excluded_count}, filtered {non_mpm_count} non-MPM, deploying {len(filtered_files)}"
         )
         return filtered_files
 
@@ -142,7 +158,7 @@ class AgentDiscoveryService:
         Returns:
             Path to template file if found, None otherwise
         """
-        template_file = self.templates_dir / f"{agent_name}.json"
+        template_file = self.templates_dir / f"{agent_name}.md"
 
         if template_file.exists():
             if self._validate_template_file(template_file):
@@ -184,40 +200,45 @@ class AgentDiscoveryService:
 
     def _extract_agent_metadata(self, template_file: Path) -> Optional[Dict[str, Any]]:
         """
-        Extract metadata from an agent template file.
+        Extract metadata from an agent template file with YAML frontmatter.
 
         Args:
-            template_file: Path to the template file
+            template_file: Path to the markdown template file
 
         Returns:
             Dictionary with agent metadata or None if extraction fails
         """
         try:
-            # Read and parse template file
+            # Read template file content
             template_content = template_file.read_text()
-            template_data = json.loads(template_content)
 
-            # Extract basic metadata from the metadata section (per agent schema)
-            metadata = template_data.get("metadata", {})
-            capabilities = template_data.get("capabilities", {})
+            # Extract YAML frontmatter
+            frontmatter = self._extract_yaml_frontmatter(template_content)
+            if not frontmatter:
+                self.logger.warning(
+                    f"No valid YAML frontmatter in {template_file.name}"
+                )
+                return None
 
+            # Extract metadata directly from frontmatter (flat structure)
+            # Markdown templates use flat YAML structure, not nested "metadata" section
             agent_info = {
-                "name": metadata.get("name", template_file.stem),
-                "description": metadata.get("description", "No description available"),
-                "version": template_data.get(
-                    "agent_version",
-                    template_data.get("version", metadata.get("version", "1.0.0")),
+                "name": frontmatter.get("name", template_file.stem),
+                "description": frontmatter.get(
+                    "description", "No description available"
+                ),
+                "type": frontmatter.get(
+                    "agent_type", frontmatter.get("category", "agent")
                 ),
-                "tools": capabilities.get("tools", []),
-                "specializations": metadata.get(
-                    "tags", []
-                ),  # Use tags as specializations
+                "version": frontmatter.get("version", "1.0.0"),
+                "tools": frontmatter.get("tools", []),
+                "specializations": frontmatter.get("tags", []),
                 "file": template_file.name,
                 "path": str(template_file),
                 "file_path": str(template_file),  # Keep for backward compatibility
                 "size": template_file.stat().st_size,
-                "model": capabilities.get("model", "sonnet"),
-                "author": metadata.get("author", "unknown"),
+                "model": frontmatter.get("model", "sonnet"),
+                "author": frontmatter.get("author", "unknown"),
             }
 
             # Validate required fields
@@ -227,8 +248,8 @@ class AgentDiscoveryService:
 
             return agent_info
 
-        except json.JSONDecodeError as e:
-            self.logger.error(f"Invalid JSON in template {template_file.name}: {e}")
+        except yaml.YAMLError as e:
+            self.logger.error(f"Invalid YAML frontmatter in {template_file.name}: {e}")
             return None
         except Exception as e:
             self.logger.error(
@@ -236,6 +257,82 @@ class AgentDiscoveryService:
             )
             return None
 
+    def _extract_yaml_frontmatter(self, content: str) -> Optional[Dict[str, Any]]:
+        """
+        Extract and parse YAML frontmatter from markdown.
+
+        Frontmatter must be at the start of the file, delimited by '---'.
+        Example:
+            ---
+            name: agent_name
+            description: Agent description
+            version: 1.0.0
+            ---
+            # Agent content...
+
+        Args:
+            content: File content to parse
+
+        Returns:
+            Parsed YAML frontmatter as dict, or None if not found/invalid
+        """
+        if not content.strip().startswith("---"):
+            return None
+
+        # Split on --- delimiters
+        parts = content.split("---", 2)
+        if len(parts) < 3:
+            return None
+
+        try:
+            return yaml.safe_load(parts[1])
+        except yaml.YAMLError as e:
+            self.logger.warning(f"Failed to parse YAML frontmatter: {e}")
+            return None
+
+    def _is_mpm_agent(self, template_file: Path) -> bool:
+        """Check if agent is authored by Claude MPM team.
+
+        MPM agents must have:
+        - An author field containing 'claude mpm', 'claude-mpm', or 'anthropic'
+        - A valid version field
+
+        Args:
+            template_file: Path to the agent template markdown file
+
+        Returns:
+            True if this is an MPM agent, False otherwise
+        """
+        try:
+            # Extract YAML frontmatter
+            content = template_file.read_text()
+            frontmatter = self._extract_yaml_frontmatter(content)
+            if not frontmatter:
+                return False
+
+            # Check for author field
+            author = frontmatter.get("author", "").lower()
+            has_valid_author = any(
+                pattern in author
+                for pattern in ["claude mpm", "claude-mpm", "anthropic"]
+            )
+
+            # Check for version field
+            has_version = bool(frontmatter.get("version"))
+
+            if not has_valid_author or not has_version:
+                self.logger.debug(
+                    f"Filtered non-MPM agent {template_file.name}: "
+                    f"author='{frontmatter.get('author', 'missing')}', "
+                    f"version={'present' if has_version else 'missing'}"
+                )
+
+            return has_valid_author and has_version
+
+        except Exception as e:
+            self.logger.debug(f"Error checking if {template_file} is MPM agent: {e}")
+            return False  # Treat invalid templates as non-MPM
+
     def _is_agent_excluded(
         self,
         agent_name: str,
@@ -292,10 +389,10 @@ class AgentDiscoveryService:
 
     def _validate_template_file(self, template_file: Path) -> bool:
         """
-        Validate that a template file is properly formatted.
+        Validate that a template file is properly formatted with YAML frontmatter.
 
         Args:
-            template_file: Path to template file to validate
+            template_file: Path to markdown template file to validate
 
         Returns:
             True if template is valid, False otherwise
@@ -305,23 +402,27 @@ class AgentDiscoveryService:
             if not template_file.exists():
                 return False
 
-            # Parse JSON content
+            # Read and parse YAML frontmatter
             content = template_file.read_text()
-            template_data = json.loads(content)
+            frontmatter = self._extract_yaml_frontmatter(content)
+            if not frontmatter:
+                self.logger.warning(
+                    f"Template {template_file.name} has no valid YAML frontmatter"
+                )
+                return False
 
-            # Check required fields in metadata section (per agent schema)
-            metadata = template_data.get("metadata", {})
+            # Check required fields (flat structure in markdown templates)
             required_fields = ["name", "description"]
             for field in required_fields:
-                if field not in metadata:
+                if field not in frontmatter:
                     self.logger.warning(
-                        f"Template {template_file.name} missing required field in metadata: {field}"
+                        f"Template {template_file.name} missing required field: {field}"
                     )
                     return False
 
             # Validate agent ID format (Claude Code requirements)
             # Use agent_id for validation, not the display name
-            agent_id = template_data.get("agent_id", "")
+            agent_id = frontmatter.get("agent_id", "")
             if not self._is_valid_agent_name(agent_id):
                 self.logger.warning(
                     f"Invalid agent ID format in {template_file.name}: {agent_id}"
@@ -330,8 +431,10 @@ class AgentDiscoveryService:
 
             return True
 
-        except json.JSONDecodeError:
-            self.logger.error(f"Invalid JSON in template: {template_file.name}")
+        except yaml.YAMLError:
+            self.logger.error(
+                f"Invalid YAML frontmatter in template: {template_file.name}"
+            )
             return False
         except Exception as e:
             self.logger.error(
@@ -357,6 +460,53 @@ class AgentDiscoveryService:
 
         return bool(re.match(pattern, agent_name))
 
+    def _is_mpm_agent_with_config(
+        self, template_file: Path, config: Optional[Config] = None
+    ) -> bool:
+        """Check if agent is authored by Claude MPM team with configurable patterns.
+
+        MPM agents must have:
+        - An author field containing configurable MPM patterns (default: 'claude mpm', 'claude-mpm', 'anthropic')
+        - A valid version field
+
+        Args:
+            template_file: Path to the agent template markdown file
+            config: Configuration object for MPM patterns
+
+        Returns:
+            True if this is an MPM agent, False otherwise
+        """
+        try:
+            # Extract YAML frontmatter
+            content = template_file.read_text()
+            frontmatter = self._extract_yaml_frontmatter(content)
+            if not frontmatter:
+                return False
+
+            # Get MPM author patterns from config
+            if config:
+                mpm_patterns = config.get(
+                    "agent_deployment.mpm_author_patterns",
+                    ["claude mpm", "claude-mpm", "anthropic"],
+                )
+            else:
+                mpm_patterns = ["claude mpm", "claude-mpm", "anthropic"]
+
+            # Check for author field
+            author = frontmatter.get("author", "").lower()
+            has_valid_author = any(
+                pattern.lower() in author for pattern in mpm_patterns
+            )
+
+            # Check for version field
+            has_version = bool(frontmatter.get("version"))
+
+            return has_valid_author and has_version
+
+        except Exception as e:
+            self.logger.debug(f"Error checking if {template_file} is MPM agent: {e}")
+            return False  # Treat invalid templates as non-MPM
+
     def get_discovery_stats(self) -> Dict[str, Any]:
         """
         Get statistics about agent discovery.
@@ -376,8 +526,8 @@ class AgentDiscoveryService:
         if not self.templates_dir.exists():
             return stats
 
-        # Count template files
-        template_files = list(self.templates_dir.glob("*.json"))
+        # Count markdown template files
+        template_files = list(self.templates_dir.glob("*.md"))
         stats["total_templates"] = len(template_files)
 
         # Validate each template

claude_mpm/services/agents/deployment/agent_filesystem_manager.py

@@ -183,9 +183,9 @@ class AgentFileSystemManager:
         try:
             # Generate backup directory name if not provided
             if not backup_dir:
-                import datetime
+                from datetime import datetime, timezone
 
-                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
                 backup_dir = agents_dir.parent / f"agents_backup_{timestamp}"
 
             # Create backup
@@ -324,7 +324,7 @@ class AgentFileSystemManager:
 
     def _convert_yaml_to_markdown(self, yaml_content: str, agent_name: str) -> str:
         """Convert YAML agent content to Markdown format with frontmatter."""
-        from datetime import datetime
+        from datetime import datetime, timezone
 
         # Extract YAML fields (simplified parsing)
         name = self._extract_yaml_field(yaml_content, "name") or agent_name
@@ -356,8 +356,8 @@ name: {name}
 description: "{description}"
 version: "{version}"
 author: "claude-mpm@anthropic.com"
-created: "{datetime.now().isoformat()}Z"
-updated: "{datetime.now().isoformat()}Z"
+created: "{datetime.now(timezone.utc).isoformat()}Z"
+updated: "{datetime.now(timezone.utc).isoformat()}Z"
 tags: ["{agent_name}", "mpm-framework"]
 tools: {tools_list}
 model: "sonnet"